home *** CD-ROM | disk | FTP | other *** search
/ CD Actual 44 / PC Actual CD 44.iso / Linux / Cygwin / full.exe / Disk1 / data1.cab / Tools / H-i586-cygwin32 / i586-cygwin32 / include / Windows32 / Structures.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-12-04  |  108.4 KB  |  4,809 lines
  1. /* 
  2.    Structures.h
  3.  
  4.    Declarations for all the Windows32 API Structures
  5.  
  6.    Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
  7.  
  8.    Author:  Scott Christley <scottc@net-community.com>
  9.    Date: 1996
  10.    
  11.    This file is part of the Windows32 API Library.
  12.  
  13.    This library is free software; you can redistribute it and/or
  14.    modify it under the terms of the GNU Library General Public
  15.    License as published by the Free Software Foundation; either
  16.    version 2 of the License, or (at your option) any later version.
  17.    
  18.    This library is distributed in the hope that it will be useful,
  19.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21.    Library General Public License for more details.
  22.  
  23.    If you are interested in a warranty or support for this source code,
  24.    contact Scott Christley <scottc@net-community.com> for more information.
  25.    
  26.    You should have received a copy of the GNU Library General Public
  27.    License along with this library; see the file COPYING.LIB.
  28.    If not, write to the Free Software Foundation, 
  29.    59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  30. */ 
  31.  
  32. #ifndef _GNU_H_WINDOWS32_STRUCTURES
  33. #define _GNU_H_WINDOWS32_STRUCTURES
  34.  
  35. #ifndef RC_INVOKED
  36.  
  37. #ifdef __cplusplus
  38. extern "C" {
  39. #endif /* __cplusplus */
  40.  
  41.  
  42. typedef struct _ABC {
  43.   int     abcA; 
  44.   UINT    abcB; 
  45.   int     abcC; 
  46. } ABC, *LPABC; 
  47.  
  48. typedef struct _ABCFLOAT {
  49.   FLOAT   abcfA; 
  50.   FLOAT   abcfB; 
  51.   FLOAT   abcfC; 
  52. } ABCFLOAT, *LPABCFLOAT; 
  53.  
  54. typedef struct tagACCEL {
  55.   BYTE   fVirt; 
  56.   WORD   key; 
  57.   WORD   cmd; 
  58. } ACCEL, *LPACCEL; 
  59.  
  60. typedef struct _ACE_HEADER {
  61.   BYTE AceType; 
  62.   BYTE AceFlags; 
  63.   WORD AceSize; 
  64. } ACE_HEADER; 
  65.  
  66. typedef DWORD ACCESS_MASK; 
  67. typedef ACCESS_MASK REGSAM;
  68.  
  69. typedef struct _ACCESS_ALLOWED_ACE {
  70.   ACE_HEADER Header; 
  71.   ACCESS_MASK Mask; 
  72.   DWORD SidStart; 
  73. } ACCESS_ALLOWED_ACE; 
  74.  
  75. typedef struct _ACCESS_DENIED_ACE {
  76.   ACE_HEADER  Header; 
  77.   ACCESS_MASK Mask; 
  78.   DWORD       SidStart; 
  79. } ACCESS_DENIED_ACE; 
  80.  
  81. typedef struct tagACCESSTIMEOUT {
  82.   UINT  cbSize; 
  83.   DWORD dwFlags; 
  84.   DWORD iTimeOutMSec; 
  85. } ACCESSTIMEOUT; 
  86.  
  87. typedef struct _ACL {
  88.   BYTE AclRevision; 
  89.   BYTE Sbz1; 
  90.   WORD AclSize; 
  91.   WORD AceCount; 
  92.   WORD Sbz2; 
  93. } ACL, *PACL; 
  94.  
  95. typedef struct _ACL_REVISION_INFORMATION {    
  96.   DWORD   AclRevision; 
  97. } ACL_REVISION_INFORMATION; 
  98.  
  99. typedef struct _ACL_SIZE_INFORMATION {
  100.   DWORD   AceCount; 
  101.   DWORD   AclBytesInUse; 
  102.   DWORD   AclBytesFree; 
  103. } ACL_SIZE_INFORMATION; 
  104.  
  105. typedef struct _ACTION_HEADER {
  106.   ULONG   transport_id; 
  107.   USHORT  action_code; 
  108.   USHORT  reserved; 
  109. } ACTION_HEADER; 
  110.  
  111. typedef struct _ADAPTER_STATUS {
  112.   UCHAR   adapter_address[6]; 
  113.   UCHAR   rev_major; 
  114.   UCHAR   reserved0; 
  115.   UCHAR   adapter_type; 
  116.   UCHAR   rev_minor; 
  117.   WORD    duration; 
  118.   WORD    frmr_recv; 
  119.   WORD    frmr_xmit; 
  120.   WORD    iframe_recv_err; 
  121.   WORD    xmit_aborts; 
  122.   DWORD   xmit_success; 
  123.   DWORD   recv_success; 
  124.   WORD    iframe_xmit_err; 
  125.   WORD    recv_buff_unavail; 
  126.   WORD    t1_timeouts; 
  127.   WORD    ti_timeouts; 
  128.   DWORD   reserved1; 
  129.   WORD    free_ncbs; 
  130.   WORD    max_cfg_ncbs; 
  131.   WORD    max_ncbs; 
  132.   WORD    xmit_buf_unavail; 
  133.   WORD    max_dgram_size; 
  134.   WORD    pending_sess; 
  135.   WORD    max_cfg_sess; 
  136.   WORD    max_sess; 
  137.   WORD    max_sess_pkt_size; 
  138.   WORD    name_count; 
  139. } ADAPTER_STATUS; 
  140.  
  141. typedef struct _ADDJOB_INFO_1 {
  142.   LPTSTR  Path; 
  143.   DWORD   JobId; 
  144. } ADDJOB_INFO_1; 
  145.  
  146. typedef struct tagANIMATIONINFO { 
  147.   UINT cbSize; 
  148.   int  iMinAnimate; 
  149. } ANIMATIONINFO, *LPANIMATIONINFO; 
  150.  
  151. typedef struct _RECT {  
  152.   LONG left;       
  153.   LONG top;        
  154.   LONG right;      
  155.   LONG bottom;     
  156. } RECT, *LPRECT, *PRECT; 
  157.  
  158. typedef struct _RECTL { 
  159.   LONG left;     
  160.   LONG top;      
  161.   LONG right;    
  162.   LONG bottom;   
  163. } RECTL; 
  164.  
  165. typedef struct _AppBarData {
  166.   DWORD  cbSize;           
  167.   HWND   hWnd;             
  168.   UINT   uCallbackMessage; 
  169.   UINT   uEdge;            
  170.   RECT   rc;               
  171.   LPARAM lParam;           
  172. } APPBARDATA, *PAPPBARDATA; 
  173.  
  174. typedef struct tagBITMAP
  175. {
  176.   LONG        bmType;
  177.   LONG        bmWidth;
  178.   LONG        bmHeight;
  179.   LONG        bmWidthBytes;
  180.   WORD        bmPlanes;
  181.   WORD        bmBitsPixel;
  182.   LPVOID      bmBits;
  183. } BITMAP, *PBITMAP,   *NPBITMAP,   *LPBITMAP;
  184.  
  185. typedef struct tagBITMAPCOREHEADER {
  186.   DWORD   bcSize; 
  187.   WORD    bcWidth; 
  188.   WORD    bcHeight; 
  189.   WORD    bcPlanes; 
  190.   WORD    bcBitCount; 
  191. } PACKED BITMAPCOREHEADER, *PBITMAPCOREHEADER, *LPBITMAPCOREHEADER; 
  192.  
  193. typedef struct tagRGBTRIPLE { 
  194.   BYTE rgbtBlue; 
  195.   BYTE rgbtGreen; 
  196.   BYTE rgbtRed; 
  197. } PACKED RGBTRIPLE, *PRGBTRIPLE, *LPRGBTRIPLE;
  198.  
  199. typedef struct tagBITMAPCOREINFO {
  200.   BITMAPCOREHEADER  bmciHeader; 
  201.   RGBTRIPLE         bmciColors[1]; 
  202. } PACKED BITMAPCOREINFO, *PBITMAPCOREINFO, *LPBITMAPCOREINFO; 
  203.  
  204. typedef struct tagBITMAPFILEHEADER {
  205.   WORD    bfType; 
  206.   DWORD   bfSize; 
  207.   WORD    bfReserved1; 
  208.   WORD    bfReserved2; 
  209.   DWORD   bfOffBits; 
  210. } PACKED BITMAPFILEHEADER; 
  211.  
  212. typedef struct tagBITMAPINFOHEADER {
  213.   DWORD  biSize; 
  214.   LONG   biWidth; 
  215.   LONG   biHeight; 
  216.   WORD   biPlanes; 
  217.   WORD   biBitCount; 
  218.   DWORD  biCompression; 
  219.   DWORD  biSizeImage; 
  220.   LONG   biXPelsPerMeter; 
  221.   LONG   biYPelsPerMeter; 
  222.   DWORD  biClrUsed; 
  223.   DWORD  biClrImportant; 
  224. } PACKED BITMAPINFOHEADER, *LPBITMAPINFOHEADER, *PBITMAPINFOHEADER; 
  225.  
  226. typedef struct tagRGBQUAD { 
  227.   BYTE    rgbBlue; 
  228.   BYTE    rgbGreen; 
  229.   BYTE    rgbRed; 
  230.   BYTE    rgbReserved; 
  231. } PACKED RGBQUAD, *PRGBQUAD, *LPRGBQUAD; 
  232.  
  233. typedef struct tagBITMAPINFO {
  234.   BITMAPINFOHEADER bmiHeader; 
  235.   RGBQUAD          bmiColors[1]; 
  236. } PACKED BITMAPINFO, *LPBITMAPINFO, *PBITMAPINFO; 
  237.  
  238. typedef struct tagBITMAPINFOMASK {
  239.   BITMAPINFOHEADER bmiHeader;
  240.   DWORD            dwMask[3];
  241. } BITMAPINFOMASK, LPBITMAPINFOMASK, *PBITMAPINFOMASK;
  242.  
  243. typedef long FXPT2DOT30,  * LPFXPT2DOT30;
  244.  
  245. typedef struct tagCIEXYZ
  246. {
  247.   FXPT2DOT30 ciexyzX; 
  248.   FXPT2DOT30 ciexyzY; 
  249.   FXPT2DOT30 ciexyzZ; 
  250. } CIEXYZ, *LPCIEXYZ; 
  251.  
  252. typedef struct tagCIEXYZTRIPLE
  253. {
  254.   CIEXYZ  ciexyzRed; 
  255.   CIEXYZ  ciexyzGreen; 
  256.   CIEXYZ  ciexyzBlue; 
  257. } CIEXYZTRIPLE, *LPCIEXYZTRIPLE; 
  258.  
  259. typedef struct {
  260.   DWORD        bV4Size;
  261.   LONG         bV4Width;
  262.   LONG         bV4Height;
  263.   WORD         bV4Planes;
  264.   WORD         bV4BitCount;
  265.   DWORD        bV4V4Compression;
  266.   DWORD        bV4SizeImage;
  267.   LONG         bV4XPelsPerMeter;
  268.   LONG         bV4YPelsPerMeter;
  269.   DWORD        bV4ClrUsed;
  270.   DWORD        bV4ClrImportant;
  271.   DWORD        bV4RedMask;
  272.   DWORD        bV4GreenMask;
  273.   DWORD        bV4BlueMask;
  274.   DWORD        bV4AlphaMask;
  275.   DWORD        bV4CSType;
  276.   CIEXYZTRIPLE bV4Endpoints;
  277.   DWORD        bV4GammaRed;
  278.   DWORD        bV4GammaGreen;
  279.   DWORD        bV4GammaBlue;
  280. } BITMAPV4HEADER,   *LPBITMAPV4HEADER, *PBITMAPV4HEADER; 
  281.  
  282. typedef struct _BLOB { 
  283.   ULONG   cbSize; 
  284.   BYTE    *pBlobData; 
  285. } BLOB; 
  286.  
  287. typedef struct _SHITEMID {       
  288.   USHORT cb;       
  289.   BYTE   abID[1];  
  290. } SHITEMID, * LPSHITEMID; 
  291. typedef const SHITEMID  * LPCSHITEMID; 
  292.  
  293. typedef struct _ITEMIDLIST { 
  294.   SHITEMID mkid;  
  295. } ITEMIDLIST, * LPITEMIDLIST; 
  296. typedef const ITEMIDLIST * LPCITEMIDLIST; 
  297.  
  298. typedef struct _browseinfo { 
  299.   HWND hwndOwner;          
  300.   LPCITEMIDLIST pidlRoot;  
  301.   LPSTR pszDisplayName;    
  302.   LPCSTR lpszTitle;        
  303.   UINT ulFlags;            
  304.   BFFCALLBACK lpfn;        
  305.   LPARAM lParam;           
  306.   int iImage;              
  307. } BROWSEINFO, *PBROWSEINFO, *LPBROWSEINFO; 
  308.  
  309. typedef struct _FILETIME { 
  310.   DWORD dwLowDateTime; 
  311.   DWORD dwHighDateTime; 
  312. } FILETIME, *LPFILETIME, *PFILETIME; 
  313.  
  314. typedef struct _BY_HANDLE_FILE_INFORMATION {
  315.   DWORD    dwFileAttributes; 
  316.   FILETIME ftCreationTime; 
  317.   FILETIME ftLastAccessTime; 
  318.   FILETIME ftLastWriteTime; 
  319.   DWORD    dwVolumeSerialNumber; 
  320.   DWORD    nFileSizeHigh; 
  321.   DWORD    nFileSizeLow; 
  322.   DWORD    nNumberOfLinks; 
  323.   DWORD    nFileIndexHigh; 
  324.   DWORD    nFileIndexLow; 
  325. } BY_HANDLE_FILE_INFORMATION, *LPBY_HANDLE_FILE_INFORMATION; 
  326.  
  327. typedef struct _FIXED { 
  328.   WORD  fract; 
  329.   short value; 
  330. } FIXED; 
  331.  
  332. typedef struct tagPOINT { 
  333.   LONG x; 
  334.   LONG y; 
  335. } POINT, *LPPOINT, *PPOINT; 
  336.  
  337. typedef struct tagPOINTFX { 
  338.   FIXED x; 
  339.   FIXED y; 
  340. } POINTFX; 
  341.  
  342. typedef struct _POINTL { 
  343.   LONG x; 
  344.   LONG y; 
  345. } POINTL; 
  346.  
  347. typedef struct tagPOINTS { 
  348.   SHORT x;    
  349.   SHORT y;    
  350. } POINTS; 
  351.  
  352. typedef struct _tagCANDIDATEFORM {
  353.   DWORD  dwIndex;       
  354.   DWORD  dwStyle;       
  355.   POINT  ptCurrentPos;  
  356.   RECT   rcArea;        
  357. } CANDIDATEFORM, *LPCANDIDATEFORM;
  358.  
  359. typedef struct _tagCANDIDATELIST {
  360.   DWORD  dwSize;       
  361.   DWORD  dwStyle;      
  362.   DWORD  dwCount;      
  363.   DWORD  dwSelection;  
  364.   DWORD  dwPageStart;  
  365.   DWORD  dwPageSize;   
  366.   DWORD  dwOffset[1];
  367. } CANDIDATELIST, *LPCANDIDATELIST;
  368.  
  369. typedef struct tagCREATESTRUCT { 
  370.   LPVOID    lpCreateParams;  
  371.   HINSTANCE hInstance;       
  372.   HMENU     hMenu;           
  373.   HWND      hwndParent;      
  374.   int       cy;              
  375.   int       cx;              
  376.   int       y;               
  377.   int       x;               
  378.   LONG      style;           
  379.   LPCTSTR   lpszName;        
  380.   LPCTSTR   lpszClass;       
  381.   DWORD     dwExStyle;       
  382. } CREATESTRUCT, *LPCREATESTRUCT; 
  383.  
  384. typedef struct tagCBT_CREATEWND {
  385.   LPCREATESTRUCT lpcs; 
  386.   HWND           hwndInsertAfter; 
  387. } CBT_CREATEWND; 
  388.  
  389. typedef struct tagCBTACTIVATESTRUCT {
  390.   WINBOOL fMouse; 
  391.   HWND hWndActive; 
  392. } CBTACTIVATESTRUCT; 
  393.  
  394. typedef struct _CHAR_INFO {
  395.   union {               
  396.     WCHAR UnicodeChar; 
  397.     CHAR AsciiChar; 
  398.   } Char; 
  399.   WORD Attributes;      
  400. } CHAR_INFO, *PCHAR_INFO; 
  401.  
  402. typedef struct _charformat { 
  403.   UINT     cbSize; 
  404.   DWORD    dwMask; 
  405.   DWORD    dwEffects; 
  406.   LONG     yHeight; 
  407.   LONG     yOffset; 
  408.   COLORREF crTextColor; 
  409.   BYTE     bCharSet; 
  410.   BYTE     bPitchAndFamily; 
  411.   TCHAR    szFaceName[LF_FACESIZE]; 
  412. } CHARFORMAT; 
  413.  
  414. typedef struct _charrange { 
  415.   LONG cpMin; 
  416.   LONG cpMax; 
  417. } CHARRANGE; 
  418.  
  419. typedef struct tagCHARSET {
  420.   DWORD aflBlock[3]; 
  421.   DWORD flLang; 
  422. } CHARSET; 
  423.  
  424. typedef struct tagFONTSIGNATURE {
  425.   DWORD  fsUsb[4];
  426.   DWORD  fsCsb[2];
  427. } FONTSIGNATURE, *LPFONTSIGNATURE; 
  428.  
  429. typedef struct {
  430.   UINT ciCharset;
  431.   UINT ciACP;
  432.   FONTSIGNATURE fs;
  433. } CHARSETINFO, *LPCHARSETINFO;
  434.  
  435. typedef struct { 
  436.   DWORD        lStructSize; 
  437.   HWND         hwndOwner; 
  438.   HWND         hInstance; 
  439.   COLORREF     rgbResult; 
  440.   COLORREF*    lpCustColors; 
  441.   DWORD        Flags; 
  442.   LPARAM       lCustData; 
  443.   LPCCHOOKPROC lpfnHook; 
  444.   LPCTSTR      lpTemplateName; 
  445. } CHOOSECOLOR, *LPCHOOSECOLOR; 
  446.  
  447. typedef struct tagLOGFONTA { 
  448.   LONG lfHeight; 
  449.   LONG lfWidth; 
  450.   LONG lfEscapement; 
  451.   LONG lfOrientation; 
  452.   LONG lfWeight; 
  453.   BYTE lfItalic; 
  454.   BYTE lfUnderline; 
  455.   BYTE lfStrikeOut; 
  456.   BYTE lfCharSet; 
  457.   BYTE lfOutPrecision; 
  458.   BYTE lfClipPrecision; 
  459.   BYTE lfQuality; 
  460.   BYTE lfPitchAndFamily; 
  461.   CHAR lfFaceName[LF_FACESIZE]; 
  462. } LOGFONTA, *LPLOGFONTA, *PLOGFONTA; 
  463.  
  464. typedef struct tagLOGFONTW { 
  465.   LONG lfHeight; 
  466.   LONG lfWidth; 
  467.   LONG lfEscapement; 
  468.   LONG lfOrientation; 
  469.   LONG lfWeight; 
  470.   BYTE lfItalic; 
  471.   BYTE lfUnderline; 
  472.   BYTE lfStrikeOut; 
  473.   BYTE lfCharSet; 
  474.   BYTE lfOutPrecision; 
  475.   BYTE lfClipPrecision; 
  476.   BYTE lfQuality; 
  477.   BYTE lfPitchAndFamily; 
  478.   WCHAR lfFaceName[LF_FACESIZE]; 
  479. } LOGFONTW, *LPLOGFONTW, *PLOGFONTW; 
  480.  
  481. #ifdef UNICODE
  482. typedef LOGFONTW LOGFONT;
  483. #else
  484. typedef LOGFONTA LOGFONT;
  485. #endif
  486.  
  487. typedef LOGFONT* PLOGFONT;
  488. typedef LOGFONT* NPLOGFONT;
  489. typedef LOGFONT* LPLOGFONT;
  490.  
  491. typedef struct { 
  492.   DWORD        lStructSize; 
  493.   HWND         hwndOwner; 
  494.   HDC          hDC; 
  495.   LPLOGFONT    lpLogFont; 
  496.   INT          iPointSize; 
  497.   DWORD        Flags; 
  498.   DWORD        rgbColors; 
  499.   LPARAM       lCustData; 
  500.   LPCFHOOKPROC lpfnHook; 
  501.   LPCTSTR      lpTemplateName; 
  502.   HINSTANCE    hInstance; 
  503.   LPTSTR       lpszStyle; 
  504.   WORD         nFontType; 
  505.   WORD         ___MISSING_ALIGNMENT__; 
  506.   INT          nSizeMin; 
  507.   INT          nSizeMax; 
  508. } CHOOSEFONT, *LPCHOOSEFONT; 
  509.  
  510. typedef struct _IDA { 
  511.   UINT cidl;     
  512.   UINT aoffset[1]; 
  513. } CIDA, * LPIDA; 
  514.  
  515. typedef struct tagCLIENTCREATESTRUCT {
  516.   HANDLE hWindowMenu; 
  517.   UINT   idFirstChild; 
  518. } CLIENTCREATESTRUCT; 
  519.  
  520. typedef CLIENTCREATESTRUCT *LPCLIENTCREATESTRUCT;
  521.  
  522. typedef struct _CMInvokeCommandInfo { 
  523.   DWORD cbSize;       
  524.   DWORD fMask;        
  525.   HWND hwnd;          
  526.   LPCSTR lpVerb;      
  527.   LPCSTR lpParameters;
  528.   LPCSTR lpDirectory; 
  529.   int nShow;          
  530.   DWORD dwHotKey;     
  531.   HANDLE hIcon;       
  532. } CMINVOKECOMMANDINFO, *LPCMINVOKECOMMANDINFO; 
  533.  
  534. typedef struct  tagCOLORADJUSTMENT {
  535.   WORD  caSize; 
  536.   WORD  caFlags; 
  537.   WORD  caIlluminantIndex; 
  538.   WORD  caRedGamma; 
  539.   WORD  caGreenGamma; 
  540.   WORD  caBlueGamma; 
  541.   WORD  caReferenceBlack; 
  542.   WORD  caReferenceWhite; 
  543.   SHORT caContrast; 
  544.   SHORT caBrightness; 
  545.   SHORT caColorfulness; 
  546.   SHORT caRedGreenTint; 
  547. } COLORADJUSTMENT, *LPCOLORADJUSTMENT; 
  548.  
  549. typedef struct _COLORMAP { 
  550.   COLORREF from; 
  551.   COLORREF to; 
  552. } COLORMAP,  * LPCOLORMAP; 
  553.  
  554. typedef struct _DCB { 
  555.   DWORD DCBlength;          
  556.   DWORD BaudRate;           
  557.   DWORD fBinary: 1;         
  558.   DWORD fParity: 1;         
  559.   DWORD fOutxCtsFlow:1;     
  560.   DWORD fOutxDsrFlow:1;     
  561.   DWORD fDtrControl:2;      
  562.   DWORD fDsrSensitivity:1;  
  563.   DWORD fTXContinueOnXoff:1;
  564.   DWORD fOutX: 1;        
  565.   DWORD fInX: 1;         
  566.   DWORD fErrorChar: 1;   
  567.   DWORD fNull: 1;        
  568.   DWORD fRtsControl:2;   
  569.   DWORD fAbortOnError:1; 
  570.   DWORD fDummy2:17;      
  571.   WORD wReserved;        
  572.   WORD XonLim;           
  573.   WORD XoffLim;          
  574.   BYTE ByteSize;         
  575.   BYTE Parity;           
  576.   BYTE StopBits;         
  577.   char XonChar;          
  578.   char XoffChar;         
  579.   char ErrorChar;        
  580.   char EofChar;          
  581.   char EvtChar;          
  582.   WORD wReserved1;       
  583. } DCB, *LPDCB; 
  584.  
  585. typedef struct _COMM_CONFIG {
  586.   DWORD dwSize;
  587.   WORD  wVersion; 
  588.   WORD  wReserved;
  589.   DCB   dcb;
  590.   DWORD dwProviderSubType;
  591.   DWORD dwProviderOffset;
  592.   DWORD dwProviderSize;
  593.   WCHAR wcProviderData[1];
  594. } COMMCONFIG, *LPCOMMCONFIG;
  595.  
  596. typedef struct _COMMPROP {
  597.   WORD  wPacketLength;       
  598.   WORD  wPacketVersion;      
  599.   DWORD dwServiceMask;       
  600.   DWORD dwReserved1;         
  601.   DWORD dwMaxTxQueue;        
  602.   DWORD dwMaxRxQueue;        
  603.   DWORD dwMaxBaud;           
  604.   DWORD dwProvSubType;       
  605.   DWORD dwProvCapabilities;  
  606.   DWORD dwSettableParams;    
  607.   DWORD dwSettableBaud;      
  608.   WORD  wSettableData;       
  609.   WORD  wSettableStopParity; 
  610.   DWORD dwCurrentTxQueue;    
  611.   DWORD dwCurrentRxQueue;    
  612.   DWORD dwProvSpec1;         
  613.   DWORD dwProvSpec2;         
  614.   WCHAR wcProvChar[1];       
  615. } COMMPROP, *LPCOMMPROP; 
  616.  
  617. typedef struct _COMMTIMEOUTS {
  618.   DWORD ReadIntervalTimeout; 
  619.   DWORD ReadTotalTimeoutMultiplier; 
  620.   DWORD ReadTotalTimeoutConstant; 
  621.   DWORD WriteTotalTimeoutMultiplier; 
  622.   DWORD WriteTotalTimeoutConstant; 
  623. } COMMTIMEOUTS,*LPCOMMTIMEOUTS; 
  624.  
  625. typedef struct tagCOMPAREITEMSTRUCT {
  626.   UINT  CtlType; 
  627.   UINT  CtlID; 
  628.   HWND  hwndItem; 
  629.   UINT  itemID1; 
  630.   DWORD itemData1; 
  631.   UINT  itemID2; 
  632.   DWORD itemData2; 
  633. } COMPAREITEMSTRUCT; 
  634.  
  635. typedef struct {
  636.   COLORREF crText;        
  637.   COLORREF crBackground;  
  638.   DWORD dwEffects;        
  639. } COMPCOLOR;
  640.  
  641. typedef struct _tagCOMPOSITIONFORM {
  642.   DWORD  dwStyle;       
  643.   POINT  ptCurrentPos;  
  644.   RECT   rcArea;        
  645. } COMPOSITIONFORM, *LPCOMPOSITIONFORM;
  646.  
  647. typedef struct _COMSTAT {
  648.   DWORD fCtsHold : 1;   
  649.   DWORD fDsrHold : 1;   
  650.   DWORD fRlsdHold : 1;  
  651.   DWORD fXoffHold : 1;  
  652.   DWORD fXoffSent : 1;  
  653.   DWORD fEof : 1;       
  654.   DWORD fTxim : 1;      
  655.   DWORD fReserved : 25; 
  656.   DWORD cbInQue;        
  657.   DWORD cbOutQue;       
  658. } COMSTAT, *LPCOMSTAT; 
  659.  
  660. typedef struct _CONSOLE_CURSOR_INFO {
  661.   DWORD  dwSize; 
  662.   WINBOOL   bVisible; 
  663. } CONSOLE_CURSOR_INFO, *PCONSOLE_CURSOR_INFO; 
  664.  
  665. typedef struct _COORD {
  666.   SHORT X;    
  667.   SHORT Y;    
  668. } COORD; 
  669.  
  670. typedef struct _SMALL_RECT { 
  671.   SHORT Left;      
  672.   SHORT Top;       
  673.   SHORT Right;     
  674.   SHORT Bottom;    
  675. } SMALL_RECT, *PSMALL_RECT; 
  676.  
  677. typedef struct _CONSOLE_SCREEN_BUFFER_INFO {
  678.   COORD      dwSize; 
  679.   COORD      dwCursorPosition; 
  680.   WORD       wAttributes; 
  681.   SMALL_RECT srWindow; 
  682.   COORD      dwMaximumWindowSize; 
  683. } CONSOLE_SCREEN_BUFFER_INFO, *PCONSOLE_SCREEN_BUFFER_INFO ; 
  684.  
  685. #ifdef __i386__
  686.  
  687. typedef struct _FLOATING_SAVE_AREA {
  688.     DWORD   ControlWord;
  689.     DWORD   StatusWord;
  690.     DWORD   TagWord;
  691.     DWORD   ErrorOffset;
  692.     DWORD   ErrorSelector;
  693.     DWORD   DataOffset;
  694.     DWORD   DataSelector;
  695.     BYTE    RegisterArea[80];
  696.     DWORD   Cr0NpxState;
  697. } FLOATING_SAVE_AREA;
  698.  
  699. typedef struct _CONTEXT {
  700.     DWORD ContextFlags;
  701.  
  702.     DWORD   Dr0;
  703.     DWORD   Dr1;
  704.     DWORD   Dr2;
  705.     DWORD   Dr3;
  706.     DWORD   Dr6;
  707.     DWORD   Dr7;
  708.  
  709.     FLOATING_SAVE_AREA FloatSave;
  710.  
  711.     DWORD   SegGs;
  712.     DWORD   SegFs;
  713.     DWORD   SegEs;
  714.     DWORD   SegDs;
  715.  
  716.     DWORD   Edi;
  717.     DWORD   Esi;
  718.     DWORD   Ebx;
  719.     DWORD   Edx;
  720.     DWORD   Ecx;
  721.     DWORD   Eax;
  722.  
  723.     DWORD   Ebp;
  724.     DWORD   Eip;
  725.     DWORD   SegCs; 
  726.     DWORD   EFlags;
  727.     DWORD   Esp;
  728.     DWORD   SegSs;
  729. } CONTEXT, *PCONTEXT, *LPCONTEXT;
  730.  
  731. #else /* __ppc__ */
  732.  
  733. typedef struct
  734.   {
  735.     /* Floating point registers returned when CONTEXT_FLOATING_POINT is set */
  736.     double Fpr0;
  737.     double Fpr1;
  738.     double Fpr2;
  739.     double Fpr3;
  740.     double Fpr4;
  741.     double Fpr5;
  742.     double Fpr6;
  743.     double Fpr7;
  744.     double Fpr8;
  745.     double Fpr9;
  746.     double Fpr10;
  747.     double Fpr11;
  748.     double Fpr12;
  749.     double Fpr13;
  750.     double Fpr14;
  751.     double Fpr15;
  752.     double Fpr16;
  753.     double Fpr17;
  754.     double Fpr18;
  755.     double Fpr19;
  756.     double Fpr20;
  757.     double Fpr21;
  758.     double Fpr22;
  759.     double Fpr23;
  760.     double Fpr24;
  761.     double Fpr25;
  762.     double Fpr26;
  763.     double Fpr27;
  764.     double Fpr28;
  765.     double Fpr29;
  766.     double Fpr30;
  767.     double Fpr31;
  768.     double Fpscr;
  769.  
  770.     /* Integer registers returned when CONTEXT_INTEGER is set.  */
  771.     DWORD Gpr0;
  772.     DWORD Gpr1;
  773.     DWORD Gpr2;
  774.     DWORD Gpr3;
  775.     DWORD Gpr4;
  776.     DWORD Gpr5;
  777.     DWORD Gpr6;
  778.     DWORD Gpr7;
  779.     DWORD Gpr8;
  780.     DWORD Gpr9;
  781.     DWORD Gpr10;
  782.     DWORD Gpr11;
  783.     DWORD Gpr12;
  784.     DWORD Gpr13;
  785.     DWORD Gpr14;
  786.     DWORD Gpr15;
  787.     DWORD Gpr16;
  788.     DWORD Gpr17;
  789.     DWORD Gpr18;
  790.     DWORD Gpr19;
  791.     DWORD Gpr20;
  792.     DWORD Gpr21;
  793.     DWORD Gpr22;
  794.     DWORD Gpr23;
  795.     DWORD Gpr24;
  796.     DWORD Gpr25;
  797.     DWORD Gpr26;
  798.     DWORD Gpr27;
  799.     DWORD Gpr28;
  800.     DWORD Gpr29;
  801.     DWORD Gpr30;
  802.     DWORD Gpr31;
  803.  
  804.     DWORD Cr;            /* Condition register */
  805.     DWORD Xer;            /* Fixed point exception register */
  806.  
  807.     /* The following are set when CONTEXT_CONTROL is set.  */
  808.     DWORD Msr;            /* Machine status register */
  809.     DWORD Iar;            /* Instruction address register */
  810.     DWORD Lr;            /* Link register */
  811.     DWORD Ctr;            /* Control register */
  812.  
  813.     /* Control which context values are returned */
  814.     DWORD ContextFlags;
  815.     DWORD Fill[3];
  816.  
  817.     /* Registers returned if CONTEXT_DEBUG_REGISTERS is set.  */
  818.     DWORD Dr0;                          /* Breakpoint Register 1 */
  819.     DWORD Dr1;                          /* Breakpoint Register 2 */
  820.     DWORD Dr2;                          /* Breakpoint Register 3 */
  821.     DWORD Dr3;                          /* Breakpoint Register 4 */
  822.     DWORD Dr4;                          /* Breakpoint Register 5 */
  823.     DWORD Dr5;                          /* Breakpoint Register 6 */
  824.     DWORD Dr6;                          /* Debug Status Register */
  825.     DWORD Dr7;                          /* Debug Control Register */
  826. } CONTEXT, *PCONTEXT, *LPCONTEXT;
  827. #endif
  828.  
  829. typedef struct _LIST_ENTRY { 
  830.   struct _LIST_ENTRY *Flink; 
  831.   struct _LIST_ENTRY *Blink; 
  832. } LIST_ENTRY, *PLIST_ENTRY; 
  833.  
  834. typedef struct _CRITICAL_SECTION_DEBUG {
  835.     WORD   Type;
  836.     WORD   CreatorBackTraceIndex;
  837.     struct _CRITICAL_SECTION *CriticalSection;
  838.     LIST_ENTRY ProcessLocksList;
  839.     DWORD EntryCount;
  840.     DWORD ContentionCount;
  841.     DWORD Depth;
  842.     PVOID OwnerBackTrace[ 5 ];
  843. } CRITICAL_SECTION_DEBUG, *PCRITICAL_SECTION_DEBUG;
  844.  
  845. typedef struct _CRITICAL_SECTION {
  846.     PCRITICAL_SECTION_DEBUG DebugInfo;
  847.     LONG LockCount;
  848.     LONG RecursionCount;
  849.     HANDLE OwningThread;
  850.     HANDLE LockSemaphore;
  851.     DWORD Reserved;
  852. } CRITICAL_SECTION, *PCRITICAL_SECTION, *LPCRITICAL_SECTION;
  853.  
  854. typedef struct _SECURITY_QUALITY_OF_SERVICE { 
  855.   DWORD Length; 
  856.   SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; 
  857.   /* SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode; */
  858.   WINBOOL ContextTrackingMode; 
  859.   BOOLEAN EffectiveOnly; 
  860. } SECURITY_QUALITY_OF_SERVICE; 
  861.  
  862. typedef struct tagCONVCONTEXT { 
  863.   UINT  cb; 
  864.   UINT  wFlags; 
  865.   UINT  wCountryID; 
  866.   int   iCodePage; 
  867.   DWORD dwLangID; 
  868.   DWORD dwSecurity; 
  869.   SECURITY_QUALITY_OF_SERVICE qos;
  870. } CONVCONTEXT; 
  871.  
  872. typedef CONVCONTEXT *PCONVCONTEXT;
  873.  
  874. typedef struct tagCONVINFO { 
  875.   DWORD       cb; 
  876.   DWORD       hUser; 
  877.   HCONV       hConvPartner; 
  878.   HSZ         hszSvcPartner; 
  879.   HSZ         hszServiceReq; 
  880.   HSZ         hszTopic; 
  881.   HSZ         hszItem; 
  882.   UINT        wFmt; 
  883.   UINT        wType; 
  884.   UINT        wStatus; 
  885.   UINT        wConvst; 
  886.   UINT        wLastError; 
  887.   HCONVLIST   hConvList; 
  888.   CONVCONTEXT ConvCtxt; 
  889.   HWND        hwnd; 
  890.   HWND        hwndPartner; 
  891. } CONVINFO; 
  892.  
  893. typedef struct tagCOPYDATASTRUCT { 
  894.   DWORD dwData; 
  895.   DWORD cbData; 
  896.   PVOID lpData; 
  897. } COPYDATASTRUCT; 
  898.  
  899. typedef struct _cpinfo { 
  900.   UINT MaxCharSize; 
  901.   BYTE DefaultChar[MAX_DEFAULTCHAR]; 
  902.   BYTE LeadByte[MAX_LEADBYTES]; 
  903. } CPINFO, *LPCPINFO; 
  904.  
  905. typedef struct tagCPLINFO { 
  906.   int  idIcon; 
  907.   int  idName; 
  908.   int  idInfo; 
  909.   LONG lData; 
  910. } CPLINFO; 
  911.  
  912. typedef struct _CREATE_PROCESS_DEBUG_INFO {
  913.   HANDLE hFile; 
  914.   HANDLE hProcess; 
  915.   HANDLE hThread; 
  916.   LPVOID lpBaseOfImage; 
  917.   DWORD dwDebugInfoFileOffset; 
  918.   DWORD nDebugInfoSize; 
  919.   LPVOID lpThreadLocalBase; 
  920.   LPTHREAD_START_ROUTINE lpStartAddress; 
  921.   LPVOID lpImageName; 
  922.   WORD fUnicode; 
  923. } CREATE_PROCESS_DEBUG_INFO; 
  924.  
  925. typedef struct _CREATE_THREAD_DEBUG_INFO {
  926.   HANDLE hThread; 
  927.   LPVOID lpThreadLocalBase; 
  928.   LPTHREAD_START_ROUTINE lpStartAddress; 
  929. } CREATE_THREAD_DEBUG_INFO; 
  930.  
  931. /*
  932.  TODO: sockets
  933. typedef struct _SOCKET_ADDRESS {
  934.   LPSOCKADDR lpSockaddr ;
  935.   INT iSockaddrLength ;
  936. } SOCKET_ADDRESS, *PSOCKET_ADDRESS, *LPSOCKET_ADDRESS;
  937. */
  938.  
  939. /*
  940. typedef struct _CSADDR_INFO { 
  941.   SOCKET_ADDRESS  LocalAddr; 
  942.   SOCKET_ADDRESS  RemoteAddr; 
  943.   INT             iSocketType; 
  944.   INT             iProtocol; 
  945. } CSADDR_INFO; 
  946. */
  947.  
  948. typedef struct _currencyfmt { 
  949.   UINT      NumDigits; 
  950.   UINT      LeadingZero; 
  951.   UINT      Grouping; 
  952.   LPTSTR    lpDecimalSep; 
  953.   LPTSTR    lpThousandSep; 
  954.   UINT      NegativeOrder; 
  955.   UINT      PositiveOrder; 
  956.   LPTSTR    lpCurrencySymbol;
  957. } CURRENCYFMT; 
  958.  
  959. typedef struct tagCURSORSHAPE {  
  960.   int     xHotSpot; 
  961.   int     yHotSpot; 
  962.   int     cx; 
  963.   int     cy; 
  964.   int     cbWidth; 
  965.   BYTE    Planes; 
  966.   BYTE    BitsPixel; 
  967. } CURSORSHAPE,   *LPCURSORSHAPE; 
  968.  
  969. typedef struct tagCWPRETSTRUCT {
  970.   LRESULT lResult; 
  971.   LPARAM  lParam; 
  972.   WPARAM  wParam; 
  973.   DWORD   message; 
  974.   HWND    hwnd; 
  975. } CWPRETSTRUCT; 
  976.  
  977. typedef struct tagCWPSTRUCT {
  978.   LPARAM  lParam; 
  979.   WPARAM  wParam; 
  980.   UINT    message; 
  981.   HWND    hwnd; 
  982. } CWPSTRUCT; 
  983.  
  984. typedef struct _DATATYPES_INFO_1 { 
  985.   LPTSTR pName; 
  986. } DATATYPES_INFO_1; 
  987.  
  988. typedef struct { 
  989.   unsigned short bAppReturnCode:8, 
  990.     reserved:6, 
  991.     fBusy:1, 
  992.     fAck:1; 
  993. } DDEACK; 
  994.  
  995. typedef struct { 
  996.   unsigned short reserved:14, 
  997.     fDeferUpd:1, 
  998.     fAckReq:1; 
  999.   short cfFormat; 
  1000. } DDEADVISE; 
  1001.  
  1002. typedef struct { 
  1003.   unsigned short unused:12, 
  1004.     fResponse:1, 
  1005.     fRelease:1, 
  1006.     reserved:1, 
  1007.     fAckReq:1; 
  1008.   short cfFormat; 
  1009.   BYTE  Value[1]; 
  1010. } DDEDATA; 
  1011.  
  1012. typedef struct { 
  1013.   unsigned short unused:13, 
  1014.     fRelease:1, 
  1015.     fDeferUpd:1, 
  1016.     fAckReq:1; 
  1017.   short cfFormat; 
  1018. } DDELN; 
  1019.  
  1020. typedef struct tagDDEML_MSG_HOOK_DATA { 
  1021.   UINT  uiLo; 
  1022.   UINT  uiHi; 
  1023.   DWORD cbData; 
  1024.   DWORD Data[8]; 
  1025. } DDEML_MSG_HOOK_DATA; 
  1026.  
  1027. typedef struct { 
  1028.   unsigned short unused:13, 
  1029.     fRelease:1, 
  1030.     fReserved:2; 
  1031.   short cfFormat; 
  1032.   BYTE  Value[1]; 
  1033. } DDEPOKE; 
  1034.  
  1035. typedef struct { 
  1036.   unsigned short unused:12, 
  1037.     fAck:1, 
  1038.     fRelease:1, 
  1039.     fReserved:1, 
  1040.     fAckReq:1; 
  1041.   short cfFormat; 
  1042.   BYTE rgb[1]; 
  1043. } DDEUP; 
  1044.  
  1045. typedef struct _EXCEPTION_RECORD { 
  1046.   DWORD ExceptionCode; 
  1047.   DWORD ExceptionFlags; 
  1048.   struct _EXCEPTION_RECORD *ExceptionRecord; 
  1049.   PVOID ExceptionAddress; 
  1050.   DWORD NumberParameters; 
  1051.   DWORD ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS]; 
  1052. } EXCEPTION_RECORD, *PEXCEPTION_RECORD, *LPEXCEPTION_RECORD; 
  1053.  
  1054. typedef struct _EXCEPTION_DEBUG_INFO {
  1055.   EXCEPTION_RECORD ExceptionRecord; 
  1056.   DWORD dwFirstChance; 
  1057. } EXCEPTION_DEBUG_INFO; 
  1058.  
  1059. typedef struct _EXIT_PROCESS_DEBUG_INFO { 
  1060.   DWORD dwExitCode; 
  1061. } EXIT_PROCESS_DEBUG_INFO; 
  1062.  
  1063. typedef struct _EXIT_THREAD_DEBUG_INFO { 
  1064.   DWORD dwExitCode; 
  1065. } EXIT_THREAD_DEBUG_INFO; 
  1066.  
  1067. typedef struct _LOAD_DLL_DEBUG_INFO { 
  1068.   HANDLE hFile; 
  1069.   LPVOID lpBaseOfDll; 
  1070.   DWORD  dwDebugInfoFileOffset; 
  1071.   DWORD  nDebugInfoSize; 
  1072.   LPVOID lpImageName; 
  1073.   WORD fUnicode; 
  1074. } LOAD_DLL_DEBUG_INFO; 
  1075.  
  1076. typedef struct _UNLOAD_DLL_DEBUG_INFO { 
  1077.   LPVOID lpBaseOfDll; 
  1078. } UNLOAD_DLL_DEBUG_INFO; 
  1079.  
  1080. typedef struct _OUTPUT_DEBUG_STRING_INFO { 
  1081.   LPSTR lpDebugStringData; 
  1082.   WORD  fUnicode; 
  1083.   WORD  nDebugStringLength; 
  1084. } OUTPUT_DEBUG_STRING_INFO; 
  1085.  
  1086. typedef struct _RIP_INFO { 
  1087.   DWORD  dwError; 
  1088.   DWORD  dwType; 
  1089. } RIP_INFO; 
  1090.  
  1091. typedef struct _DEBUG_EVENT { 
  1092.   DWORD dwDebugEventCode; 
  1093.   DWORD dwProcessId; 
  1094.   DWORD dwThreadId; 
  1095.   union { 
  1096.     EXCEPTION_DEBUG_INFO Exception; 
  1097.     CREATE_THREAD_DEBUG_INFO CreateThread; 
  1098.     CREATE_PROCESS_DEBUG_INFO CreateProcessInfo; 
  1099.     EXIT_THREAD_DEBUG_INFO ExitThread; 
  1100.     EXIT_PROCESS_DEBUG_INFO ExitProcess; 
  1101.     LOAD_DLL_DEBUG_INFO LoadDll; 
  1102.     UNLOAD_DLL_DEBUG_INFO UnloadDll; 
  1103.     OUTPUT_DEBUG_STRING_INFO DebugString; 
  1104.     RIP_INFO RipInfo; 
  1105.   } u; 
  1106. } DEBUG_EVENT, *LPDEBUG_EVENT; 
  1107.  
  1108. typedef struct tagDEBUGHOOKINFO {
  1109.   DWORD  idThread; 
  1110.   DWORD  idThreadInstaller; 
  1111.   LPARAM lParam; 
  1112.   WPARAM wParam; 
  1113.   int    code; 
  1114. } DEBUGHOOKINFO; 
  1115.  
  1116. typedef struct tagDELETEITEMSTRUCT { 
  1117.   UINT CtlType; 
  1118.   UINT CtlID; 
  1119.   UINT itemID; 
  1120.   HWND hwndItem; 
  1121.   UINT itemData; 
  1122. } DELETEITEMSTRUCT; 
  1123.  
  1124. typedef struct _DEV_BROADCAST_HDR {
  1125.   ULONG dbch_size; 
  1126.   ULONG dbch_devicetype; 
  1127.   ULONG dbch_reserved; 
  1128. } DEV_BROADCAST_HDR;
  1129. typedef DEV_BROADCAST_HDR *PDEV_BROADCAST_HDR;
  1130.  
  1131. typedef struct _DEV_BROADCAST_OEM {
  1132.   ULONG dbco_size; 
  1133.   ULONG dbco_devicetype; 
  1134.   ULONG dbco_reserved; 
  1135.   ULONG dbco_identifier; 
  1136.   ULONG dbco_suppfunc; 
  1137. } DEV_BROADCAST_OEM;
  1138. typedef DEV_BROADCAST_OEM *PDEV_BROADCAST_OEM;
  1139.  
  1140. typedef struct _DEV_BROADCAST_PORT {
  1141.   ULONG dbcp_size; 
  1142.   ULONG dbcp_devicetype; 
  1143.   ULONG dbcp_reserved; 
  1144.   char dbcp_name[1]; 
  1145. } DEV_BROADCAST_PORT;
  1146. typedef DEV_BROADCAST_PORT *PDEV_BROADCAST_PORT;
  1147.  
  1148. struct _DEV_BROADCAST_USERDEFINED { 
  1149.   struct _DEV_BROADCAST_HDR dbud_dbh; 
  1150.   char  dbud_szName[1];
  1151.   BYTE  dbud_rgbUserDefined[1];
  1152. }; 
  1153.  
  1154. typedef struct _DEV_BROADCAST_VOLUME {
  1155.   ULONG dbcv_size; 
  1156.   ULONG dbcv_devicetype; 
  1157.   ULONG dbcv_reserved; 
  1158.   ULONG dbcv_unitmask; 
  1159.   USHORT dbcv_flags; 
  1160. } DEV_BROADCAST_VOLUME;
  1161. typedef DEV_BROADCAST_VOLUME *PDEV_BROADCAST_VOLUME;
  1162.  
  1163. typedef struct _devicemode {  
  1164.   BCHAR  dmDeviceName[CCHDEVICENAME]; 
  1165.   WORD   dmSpecVersion; 
  1166.   WORD   dmDriverVersion; 
  1167.   WORD   dmSize; 
  1168.   WORD   dmDriverExtra; 
  1169.   DWORD  dmFields; 
  1170.   short  dmOrientation; 
  1171.   short  dmPaperSize; 
  1172.   short  dmPaperLength; 
  1173.   short  dmPaperWidth; 
  1174.   short  dmScale; 
  1175.   short  dmCopies; 
  1176.   short  dmDefaultSource; 
  1177.   short  dmPrintQuality; 
  1178.   short  dmColor; 
  1179.   short  dmDuplex; 
  1180.   short  dmYResolution; 
  1181.   short  dmTTOption; 
  1182.   short  dmCollate; 
  1183.   BCHAR  dmFormName[CCHFORMNAME]; 
  1184.   WORD  dmLogPixels; 
  1185.   DWORD  dmBitsPerPel; 
  1186.   DWORD  dmPelsWidth; 
  1187.   DWORD  dmPelsHeight; 
  1188.   DWORD  dmDisplayFlags; 
  1189.   DWORD  dmDisplayFrequency; 
  1190.   DWORD  dmICMMethod;         
  1191.   DWORD  dmICMIntent;         
  1192.   DWORD  dmMediaType;         
  1193.   DWORD  dmDitherType;        
  1194.   DWORD  dmICCManufacturer;   
  1195.   DWORD  dmICCModel;          
  1196. } DEVMODE, *PDEVMODE, *NPDEVMODE, *LPDEVMODE;
  1197.  
  1198. #ifdef UNICODE
  1199. typedef DEVMODE DEVMODEW;
  1200. typedef PDEVMODE PDEVMODEW;
  1201. typedef NPDEVMODE NPDEVMODEW;
  1202. typedef LPDEVMODE LPDEVMODEW;
  1203. #else
  1204. typedef DEVMODE DEVMODEA;
  1205. typedef PDEVMODE PDEVMODEA;
  1206. typedef NPDEVMODE NPDEVMODEA;
  1207. typedef LPDEVMODE LPDEVMODEA;
  1208. #endif /* UNICODE */
  1209.  
  1210. typedef struct tagDEVNAMES { 
  1211.   WORD wDriverOffset; 
  1212.   WORD wDeviceOffset; 
  1213.   WORD wOutputOffset; 
  1214.   WORD wDefault; 
  1215. } DEVNAMES, *LPDEVNAMES; 
  1216.  
  1217. typedef struct tagDIBSECTION { 
  1218.   BITMAP              dsBm; 
  1219.   BITMAPINFOHEADER    dsBmih; 
  1220.   DWORD               dsBitfields[3]; 
  1221.   HANDLE              dshSection; 
  1222.   DWORD               dsOffset; 
  1223. } DIBSECTION; 
  1224.  
  1225. typedef struct _LARGE_INTEGER { 
  1226.   DWORD LowPart; 
  1227.   LONG  HighPart; 
  1228. } LARGE_INTEGER, *PLARGE_INTEGER; 
  1229.  
  1230. typedef struct _DISK_GEOMETRY { 
  1231.   LARGE_INTEGER  Cylinders; 
  1232.   MEDIA_TYPE  MediaType; 
  1233.   DWORD  TracksPerCylinder; 
  1234.   DWORD  SectorsPerTrack; 
  1235.   DWORD  BytesPerSector; 
  1236. } DISK_GEOMETRY ; 
  1237.  
  1238. typedef struct _DISK_PERFORMANCE { 
  1239.   LARGE_INTEGER BytesRead; 
  1240.   LARGE_INTEGER BytesWritten; 
  1241.   LARGE_INTEGER ReadTime; 
  1242.   LARGE_INTEGER WriteTime; 
  1243.   DWORD ReadCount; 
  1244.   DWORD WriteCount; 
  1245.   DWORD QueueDepth; 
  1246. } DISK_PERFORMANCE ; 
  1247.  
  1248. typedef struct tagDLGITEMTEMPLATE { 
  1249.   DWORD style; 
  1250.   DWORD dwExtendedStyle; 
  1251.   short x; 
  1252.   short y; 
  1253.   short cx; 
  1254.   short cy; 
  1255.   WORD  id; 
  1256. } PACKED DLGITEMTEMPLATE, *LPDLGITEMTEMPLATE, *PDLGITEMTEMPLATE;
  1257.  
  1258. typedef struct tagDLGTEMPLATE { 
  1259.   DWORD style; 
  1260.   DWORD dwExtendedStyle; 
  1261.   WORD  cdit; 
  1262.   short x; 
  1263.   short y; 
  1264.   short cx; 
  1265.   short cy; 
  1266. } PACKED DLGTEMPLATE, *LPDLGTEMPLATE, *LPCDLGTEMPLATE;
  1267.  
  1268. typedef struct _DOC_INFO_1 { 
  1269.   LPTSTR pDocName; 
  1270.   LPTSTR pOutputFile; 
  1271.   LPTSTR pDatatype; 
  1272. } DOC_INFO_1; 
  1273.  
  1274. typedef struct _DOC_INFO_2 { 
  1275.   LPTSTR pDocName; 
  1276.   LPTSTR pOutputFile; 
  1277.   LPTSTR pDatatype; 
  1278.   DWORD  dwMode; 
  1279.   DWORD  JobId; 
  1280. } DOC_INFO_2; 
  1281.  
  1282. typedef struct {    
  1283.   int     cbSize; 
  1284.   LPCTSTR lpszDocName; 
  1285.   LPCTSTR lpszOutput; 
  1286.   LPCTSTR lpszDatatype; 
  1287.   DWORD   fwType;       
  1288. } DOCINFO, *LPDOCINFO; 
  1289.  
  1290. typedef struct { 
  1291.   UINT uNotification; 
  1292.   HWND hWnd; 
  1293.   POINT ptCursor; 
  1294. } DRAGLISTINFO, *LPDRAGLISTINFO; 
  1295.  
  1296. typedef struct tagDRAWITEMSTRUCT { 
  1297.   UINT  CtlType; 
  1298.   UINT  CtlID; 
  1299.   UINT  itemID; 
  1300.   UINT  itemAction; 
  1301.   UINT  itemState; 
  1302.   HWND  hwndItem; 
  1303.   HDC   hDC; 
  1304.   RECT  rcItem; 
  1305.   DWORD itemData; 
  1306. } DRAWITEMSTRUCT, *LPDRAWITEMSTRUCT, *PDRAWITEMSTRUCT; 
  1307.  
  1308. typedef struct { 
  1309.   UINT cbSize;         
  1310.   int  iTabLength;     
  1311.   int  iLeftMargin;    
  1312.   int  iRightMargin;   
  1313.   UINT uiLengthDrawn;  
  1314. } DRAWTEXTPARAMS, *LPDRAWTEXTPARAMS; 
  1315.  
  1316. typedef struct _PARTITION_INFORMATION { 
  1317.   BYTE PartitionType; 
  1318.   BOOLEAN BootIndicator; 
  1319.   BOOLEAN RecognizedPartition; 
  1320.   BOOLEAN RewritePartition; 
  1321.   LARGE_INTEGER StartingOffset; 
  1322.   LARGE_INTEGER PartitionLength; 
  1323.   LARGE_INTEGER HiddenSectors; 
  1324. } PARTITION_INFORMATION ; 
  1325.  
  1326. typedef struct _DRIVE_LAYOUT_INFORMATION { 
  1327.   DWORD  PartitionCount; 
  1328.   DWORD  Signature; 
  1329.   PARTITION_INFORMATION  PartitionEntry[1]; 
  1330. } DRIVE_LAYOUT_INFORMATION; 
  1331.  
  1332. typedef struct _DRIVER_INFO_1 { 
  1333.   LPTSTR pName; 
  1334. } DRIVER_INFO_1; 
  1335.  
  1336. typedef struct _DRIVER_INFO_2 { 
  1337.   DWORD  cVersion; 
  1338.   LPTSTR pName; 
  1339.   LPTSTR pEnvironment; 
  1340.   LPTSTR pDriverPath; 
  1341.   LPTSTR pDataFile; 
  1342.   LPTSTR pConfigFile; 
  1343. } DRIVER_INFO_2; 
  1344.  
  1345. typedef struct _DRIVER_INFO_3 { 
  1346.   DWORD  cVersion; 
  1347.   LPTSTR pName; 
  1348.   LPTSTR pEnvironment; 
  1349.   LPTSTR pDriverPath; 
  1350.   LPTSTR pDataFile; 
  1351.   LPTSTR pConfigFile; 
  1352.   LPTSTR pHelpFile; 
  1353.   LPTSTR pDependentFiles; 
  1354.   LPTSTR pMonitorName; 
  1355.   LPTSTR pDefaultDataType; 
  1356. } DRIVER_INFO_3; 
  1357.  
  1358. typedef struct _editstream { 
  1359.   DWORD dwCookie; 
  1360.   DWORD dwError; 
  1361.   EDITSTREAMCALLBACK pfnCallback; 
  1362. } EDITSTREAM; 
  1363.  
  1364. typedef struct tagEMR
  1365. {
  1366.   DWORD iType; 
  1367.   DWORD nSize;
  1368. } EMR, *PEMR; 
  1369.  
  1370. typedef struct tagEMRANGLEARC
  1371. {
  1372.   EMR     emr;
  1373.   POINTL  ptlCenter; 
  1374.   DWORD   nRadius;
  1375.   FLOAT   eStartAngle;
  1376.   FLOAT   eSweepAngle;
  1377. } EMRANGLEARC, *PEMRANGLEARC; 
  1378.  
  1379. typedef struct tagEMRARC
  1380. {
  1381.   EMR    emr; 
  1382.   RECTL  rclBox;
  1383.   POINTL ptlStart;
  1384.   POINTL ptlEnd;
  1385. } EMRARC,   *PEMRARC,
  1386.     EMRARCTO, *PEMRARCTO,
  1387.     EMRCHORD, *PEMRCHORD,
  1388.     EMRPIE,   *PEMRPIE; 
  1389.  
  1390. typedef struct  _XFORM
  1391. {
  1392.   FLOAT   eM11;
  1393.   FLOAT   eM12;
  1394.   FLOAT   eM21;
  1395.   FLOAT   eM22;
  1396.   FLOAT   eDx;
  1397.   FLOAT   eDy;
  1398. } XFORM, *PXFORM, *LPXFORM;
  1399.  
  1400. typedef struct tagEMRBITBLT
  1401. {
  1402.   EMR      emr; 
  1403.   RECTL    rclBounds; 
  1404.   LONG     xDest; 
  1405.   LONG     yDest; 
  1406.   LONG     cxDest; 
  1407.   LONG     cyDest; 
  1408.   DWORD    dwRop; 
  1409.   LONG     xSrc; 
  1410.   LONG     ySrc; 
  1411.   XFORM    xformSrc; 
  1412.   COLORREF crBkColorSrc; 
  1413.   DWORD    iUsageSrc; 
  1414.   DWORD    offBmiSrc; 
  1415.   DWORD    offBitsSrc; 
  1416.   DWORD    cbBitsSrc; 
  1417. } EMRBITBLT, *PEMRBITBLT; 
  1418.  
  1419. typedef struct tagLOGBRUSH { 
  1420.   UINT     lbStyle; 
  1421.   COLORREF lbColor; 
  1422.   LONG     lbHatch; 
  1423. } LOGBRUSH; 
  1424.  
  1425. typedef struct tagEMRCREATEBRUSHINDIRECT
  1426. {
  1427.   EMR      emr; 
  1428.   DWORD    ihBrush; 
  1429.   LOGBRUSH lb; 
  1430. } EMRCREATEBRUSHINDIRECT, *PEMRCREATEBRUSHINDIRECT; 
  1431.  
  1432. typedef LONG LCSCSTYPE;
  1433. typedef LONG LCSGAMUTMATCH;
  1434.  
  1435. typedef struct tagLOGCOLORSPACE {
  1436.   DWORD         lcsSignature; 
  1437.   DWORD         lcsVersion; 
  1438.   DWORD         lcsSize; 
  1439.  
  1440.   LCSCSTYPE     lcsCSType; 
  1441.   LCSGAMUTMATCH lcsIntent; 
  1442.   CIEXYZTRIPLE  lcsEndpoints;
  1443.   DWORD         lcsGammaRed;
  1444.   DWORD         lcsGammaGreen; 
  1445.   DWORD         lcsGammaBlue;
  1446.   TCHAR         lcsFilename[MAX_PATH]; 
  1447. } LOGCOLORSPACE, *LPLOGCOLORSPACE; 
  1448.  
  1449. typedef struct tagEMRCREATECOLORSPACE
  1450. {
  1451.   EMR           emr; 
  1452.   DWORD         ihCS; 
  1453.   LOGCOLORSPACE lcs; 
  1454. } EMRCREATECOLORSPACE, *PEMRCREATECOLORSPACE; 
  1455.  
  1456. typedef struct tagEMRCREATEDIBPATTERNBRUSHPT
  1457. {
  1458.   EMR   emr; 
  1459.   DWORD ihBrush; 
  1460.   DWORD iUsage; 
  1461.   DWORD offBmi; 
  1462.   DWORD cbBmi; 
  1463.   DWORD offBits; 
  1464.   DWORD cbBits; 
  1465. } EMRCREATEDIBPATTERNBRUSHPT, *PEMRCREATEDIBPATTERNBRUSHPT; 
  1466.  
  1467. typedef struct tagEMRCREATEMONOBRUSH
  1468. {
  1469.   EMR   emr; 
  1470.   DWORD ihBrush; 
  1471.   DWORD iUsage; 
  1472.   DWORD offBmi; 
  1473.   DWORD cbBmi; 
  1474.   DWORD offBits; 
  1475.   DWORD cbBits; 
  1476. } EMRCREATEMONOBRUSH, *PEMRCREATEMONOBRUSH; 
  1477.  
  1478. typedef struct tagPALETTEENTRY { 
  1479.   BYTE peRed; 
  1480.   BYTE peGreen; 
  1481.   BYTE peBlue; 
  1482.   BYTE peFlags; 
  1483. } PACKED PALETTEENTRY, *LPPALETTEENTRY, *PPALETTEENTRY; 
  1484.  
  1485. typedef struct tagLOGPALETTE { 
  1486.   WORD         palVersion; 
  1487.   WORD         palNumEntries; 
  1488.   PALETTEENTRY palPalEntry[1]; 
  1489. } PACKED LOGPALETTE, *LPLOGPALETTE, *PLOGPALETTE; 
  1490.  
  1491. typedef struct tagEMRCREATEPALETTE
  1492. {
  1493.   EMR        emr; 
  1494.   DWORD      ihPal; 
  1495.   LOGPALETTE lgpl; 
  1496. } EMRCREATEPALETTE, *PEMRCREATEPALETTE; 
  1497.  
  1498. typedef struct tagLOGPEN { 
  1499.   UINT     lopnStyle; 
  1500.   POINT    lopnWidth; 
  1501.   COLORREF lopnColor; 
  1502. } LOGPEN; 
  1503.  
  1504. typedef struct tagEMRCREATEPEN
  1505. {
  1506.   EMR    emr; 
  1507.   DWORD  ihPen; 
  1508.   LOGPEN lopn; 
  1509. } EMRCREATEPEN, *PEMRCREATEPEN; 
  1510.  
  1511. typedef struct tagEMRELLIPSE
  1512. {
  1513.   EMR   emr; 
  1514.   RECTL rclBox; 
  1515. } EMRELLIPSE,  *PEMRELLIPSE,
  1516.     EMRRECTANGLE, *PEMRRECTANGLE; 
  1517.  
  1518. typedef struct tagEMREOF
  1519. {
  1520.   EMR     emr;
  1521.   DWORD   nPalEntries; 
  1522.   DWORD   offPalEntries; 
  1523.   DWORD   nSizeLast; 
  1524. } EMREOF, *PEMREOF; 
  1525.  
  1526. typedef struct tagEMREXCLUDECLIPRECT
  1527. {
  1528.   EMR   emr;      
  1529.   RECTL rclClip;  
  1530. } EMREXCLUDECLIPRECT,   *PEMREXCLUDECLIPRECT,
  1531.     EMRINTERSECTCLIPRECT, *PEMRINTERSECTCLIPRECT; 
  1532.  
  1533. typedef struct tagPANOSE { 
  1534.   BYTE bFamilyType; 
  1535.   BYTE bSerifStyle; 
  1536.   BYTE bWeight; 
  1537.   BYTE bProportion; 
  1538.   BYTE bContrast; 
  1539.   BYTE bStrokeVariation; 
  1540.   BYTE bArmStyle; 
  1541.   BYTE bLetterform; 
  1542.   BYTE bMidline; 
  1543.   BYTE bXHeight; 
  1544. } PANOSE; 
  1545.  
  1546. typedef struct tagEXTLOGFONT { 
  1547.     LOGFONT elfLogFont; 
  1548.     BCHAR    elfFullName[LF_FULLFACESIZE]; 
  1549.     BCHAR    elfStyle[LF_FACESIZE]; 
  1550.     DWORD   elfVersion; 
  1551.     DWORD   elfStyleSize; 
  1552.     DWORD   elfMatch; 
  1553.     DWORD   elfReserved; 
  1554.     BYTE    elfVendorId[ELF_VENDOR_SIZE]; 
  1555.     DWORD   elfCulture; 
  1556.     PANOSE  elfPanose; 
  1557. } EXTLOGFONT; 
  1558.  
  1559. typedef struct tagEMREXTCREATEFONTINDIRECTW
  1560. {
  1561.   EMR         emr; 
  1562.   DWORD       ihFont; 
  1563.   EXTLOGFONT  elfw; 
  1564. } EMREXTCREATEFONTINDIRECTW, *PEMREXTCREATEFONTINDIRECTW; 
  1565.  
  1566. typedef struct tagEXTLOGPEN { 
  1567.   UINT     elpPenStyle; 
  1568.   UINT     elpWidth; 
  1569.   UINT     elpBrushStyle; 
  1570.   COLORREF elpColor; 
  1571.   LONG     elpHatch; 
  1572.   DWORD    elpNumEntries; 
  1573.   DWORD    elpStyleEntry[1]; 
  1574. } EXTLOGPEN; 
  1575.  
  1576. typedef struct tagEMREXTCREATEPEN
  1577. {
  1578.   EMR       emr; 
  1579.   DWORD     ihPen; 
  1580.   DWORD     offBmi; 
  1581.   DWORD     cbBmi; 
  1582.   DWORD     offBits; 
  1583.   DWORD     cbBits; 
  1584.   EXTLOGPEN elp; 
  1585. } EMREXTCREATEPEN, *PEMREXTCREATEPEN; 
  1586.  
  1587. typedef struct tagEMREXTFLOODFILL
  1588. {
  1589.   EMR     emr; 
  1590.   POINTL  ptlStart; 
  1591.   COLORREF crColor; 
  1592.   DWORD   iMode; 
  1593. } EMREXTFLOODFILL, *PEMREXTFLOODFILL; 
  1594.  
  1595. typedef struct tagEMREXTSELECTCLIPRGN
  1596. {
  1597.   EMR   emr; 
  1598.   DWORD cbRgnData; 
  1599.   DWORD iMode; 
  1600.   BYTE  RgnData[1]; 
  1601. } EMREXTSELECTCLIPRGN, *PEMREXTSELECTCLIPRGN; 
  1602.  
  1603. typedef struct tagEMRTEXT 
  1604. {
  1605.   POINTL ptlReference; 
  1606.   DWORD  nChars; 
  1607.   DWORD  offString; 
  1608.   DWORD  fOptions; 
  1609.   RECTL  rcl; 
  1610.   DWORD  offDx; 
  1611. } EMRTEXT, *PEMRTEXT; 
  1612.  
  1613. typedef struct tagEMREXTTEXTOUTA
  1614. {
  1615.   EMR     emr; 
  1616.   RECTL   rclBounds; 
  1617.   DWORD   iGraphicsMode; 
  1618.   FLOAT   exScale; 
  1619.   FLOAT   eyScale;
  1620.   EMRTEXT emrtext; 
  1621. } EMREXTTEXTOUTA, *PEMREXTTEXTOUTA,
  1622.     EMREXTTEXTOUTW, *PEMREXTTEXTOUTW; 
  1623.  
  1624. typedef struct tagEMRFILLPATH
  1625. {
  1626.   EMR   emr; 
  1627.   RECTL rclBounds; 
  1628. } EMRFILLPATH,          *PEMRFILLPATH,
  1629.     EMRSTROKEANDFILLPATH, *PEMRSTROKEANDFILLPATH,
  1630.     EMRSTROKEPATH,        *PEMRSTROKEPATH; 
  1631.  
  1632. typedef struct tagEMRFILLRGN
  1633. {
  1634.   EMR   emr; 
  1635.   RECTL rclBounds; 
  1636.   DWORD cbRgnData; 
  1637.   DWORD ihBrush; 
  1638.   BYTE  RgnData[1]; 
  1639. } EMRFILLRGN, *PEMRFILLRGN; 
  1640.  
  1641. typedef struct tagEMRFORMAT { 
  1642.   DWORD   dSignature; 
  1643.   DWORD   nVersion; 
  1644.   DWORD   cbData; 
  1645.   DWORD   offData; 
  1646. } EMRFORMAT; 
  1647.  
  1648. typedef struct tagSIZE { 
  1649.   LONG cx; 
  1650.   LONG cy; 
  1651. } SIZE, *PSIZE, *LPSIZE, SIZEL, *PSIZEL, *LPSIZEL; 
  1652.  
  1653. typedef struct tagEMRFRAMERGN
  1654. {
  1655.   EMR   emr; 
  1656.   RECTL rclBounds; 
  1657.   DWORD cbRgnData; 
  1658.   DWORD ihBrush; 
  1659.   SIZEL szlStroke; 
  1660.   BYTE  RgnData[1]; 
  1661. } EMRFRAMERGN, *PEMRFRAMERGN; 
  1662.  
  1663. typedef struct tagEMRGDICOMMENT
  1664. {
  1665.   EMR   emr; 
  1666.   DWORD cbData; 
  1667.   BYTE  Data[1]; 
  1668. } EMRGDICOMMENT, *PEMRGDICOMMENT; 
  1669.  
  1670. typedef struct tagEMRINVERTRGN
  1671. {
  1672.   EMR   emr; 
  1673.   RECTL rclBounds; 
  1674.   DWORD cbRgnData; 
  1675.   BYTE  RgnData[1]; 
  1676. } EMRINVERTRGN, *PEMRINVERTRGN,
  1677.     EMRPAINTRGN,  *PEMRPAINTRGN; 
  1678.  
  1679. typedef struct tagEMRLINETO
  1680. {
  1681.   EMR    emr; 
  1682.   POINTL ptl; 
  1683. } EMRLINETO,   *PEMRLINETO,
  1684.     EMRMOVETOEX, *PEMRMOVETOEX; 
  1685.  
  1686. typedef struct tagEMRMASKBLT
  1687. {
  1688.   EMR     emr; 
  1689.   RECTL   rclBounds; 
  1690.   LONG    xDest; 
  1691.   LONG    yDest; 
  1692.   LONG    cxDest; 
  1693.   LONG    cyDest; 
  1694.   DWORD   dwRop; 
  1695.   LONG    xSrc; 
  1696.   LONG    ySrc; 
  1697.   XFORM   xformSrc; 
  1698.   COLORREF crBkColorSrc; 
  1699.   DWORD   iUsageSrc; 
  1700.   DWORD   offBmiSrc; 
  1701.   DWORD   cbBmiSrc; 
  1702.   DWORD   offBitsSrc; 
  1703.   DWORD   cbBitsSrc; 
  1704.   LONG    xMask; 
  1705.   LONG    yMask; 
  1706.   DWORD   iUsageMask; 
  1707.   DWORD   offBmiMask; 
  1708.   DWORD   cbBmiMask; 
  1709.   DWORD   offBitsMask; 
  1710.   DWORD   cbBitsMask; 
  1711. } EMRMASKBLT, *PEMRMASKBLT; 
  1712.  
  1713. typedef struct tagEMRMODIFYWORLDTRANSFORM
  1714. {
  1715.   EMR   emr; 
  1716.   XFORM xform; 
  1717.   DWORD iMode; 
  1718. } EMRMODIFYWORLDTRANSFORM, *PEMRMODIFYWORLDTRANSFORM; 
  1719.  
  1720. typedef struct tagEMROFFSETCLIPRGN
  1721. {
  1722.   EMR    emr; 
  1723.   POINTL ptlOffset; 
  1724. } EMROFFSETCLIPRGN, *PEMROFFSETCLIPRGN; 
  1725.  
  1726. typedef struct tagEMRPLGBLT
  1727. {
  1728.   EMR      emr; 
  1729.   RECTL    rclBounds; 
  1730.   POINTL   aptlDest[3]; 
  1731.   LONG    xSrc; 
  1732.   LONG    ySrc; 
  1733.   LONG     cxSrc; 
  1734.   LONG     cySrc; 
  1735.   XFORM   xformSrc; 
  1736.   COLORREF crBkColorSrc; 
  1737.   DWORD    iUsageSrc; 
  1738.   DWORD    offBmiSrc; 
  1739.   DWORD   cbBmiSrc; 
  1740.   DWORD   offBitsSrc; 
  1741.   DWORD   cbBitsSrc; 
  1742.   LONG    xMask;
  1743.   LONG    yMask; 
  1744.   DWORD   iUsageMask; 
  1745.   DWORD   offBmiMask; 
  1746.   DWORD   cbBmiMask;
  1747.   DWORD   offBitsMask;
  1748.   DWORD   cbBitsMask;
  1749. } EMRPLGBLT, *PEMRPLGBLT; 
  1750.  
  1751. typedef struct tagEMRPOLYDRAW
  1752. {
  1753.   EMR    emr; 
  1754.   RECTL  rclBounds; 
  1755.   DWORD  cptl; 
  1756.   POINTL aptl[1]; 
  1757.   BYTE   abTypes[1]; 
  1758. } EMRPOLYDRAW, *PEMRPOLYDRAW; 
  1759.  
  1760. typedef struct tagEMRPOLYDRAW16
  1761. {
  1762.   EMR    emr; 
  1763.   RECTL  rclBounds; 
  1764.   DWORD  cpts; 
  1765.   POINTS apts[1]; 
  1766.   BYTE   abTypes[1]; 
  1767. } EMRPOLYDRAW16, *PEMRPOLYDRAW16; 
  1768.  
  1769. typedef struct tagEMRPOLYLINE
  1770. {
  1771.   EMR    emr;
  1772.   RECTL  rclBounds; 
  1773.   DWORD  cptl; 
  1774.   POINTL aptl[1]; 
  1775. } EMRPOLYLINE,     *PEMRPOLYLINE,
  1776.     EMRPOLYBEZIER,   *PEMRPOLYBEZIER,
  1777.     EMRPOLYGON,      *PEMRPOLYGON,
  1778.     EMRPOLYBEZIERTO, *PEMRPOLYBEZIERTO,
  1779.     EMRPOLYLINETO,   *PEMRPOLYLINETO; 
  1780.  
  1781. typedef struct tagEMRPOLYLINE16
  1782. {
  1783.   EMR    emr; 
  1784.   RECTL  rclBounds; 
  1785.   DWORD  cpts; 
  1786.   POINTL apts[1]; 
  1787. } EMRPOLYLINE16,     *PEMRPOLYLINE16,
  1788.     EMRPOLYBEZIER16,   *PEMRPOLYBEZIER16,
  1789.     EMRPOLYGON16,      *PEMRPOLYGON16,
  1790.     EMRPOLYBEZIERTO16, *PEMRPOLYBEZIERTO16,
  1791.     EMRPOLYLINETO16,   *PEMRPOLYLINETO16; 
  1792.  
  1793. typedef struct tagEMRPOLYPOLYLINE
  1794. {
  1795.   EMR     emr; 
  1796.   RECTL   rclBounds; 
  1797.   DWORD   nPolys; 
  1798.   DWORD   cptl; 
  1799.   DWORD   aPolyCounts[1]; 
  1800.   POINTL  aptl[1]; 
  1801. } EMRPOLYPOLYLINE, *PEMRPOLYPOLYLINE,
  1802.     EMRPOLYPOLYGON,  *PEMRPOLYPOLYGON; 
  1803.  
  1804. typedef struct tagEMRPOLYPOLYLINE16
  1805. {
  1806.   EMR     emr; 
  1807.   RECTL   rclBounds;
  1808.   DWORD   nPolys; 
  1809.   DWORD   cpts; 
  1810.   DWORD   aPolyCounts[1]; 
  1811.   POINTS  apts[1]; 
  1812. } EMRPOLYPOLYLINE16, *PEMRPOLYPOLYLINE16,
  1813.     EMRPOLYPOLYGON16,  *PEMRPOLYPOLYGON16; 
  1814.  
  1815. typedef struct tagEMRPOLYTEXTOUTA
  1816. {
  1817.   EMR     emr; 
  1818.   RECTL   rclBounds; 
  1819.   DWORD   iGraphicsMode; 
  1820.   FLOAT   exScale; 
  1821.   FLOAT   eyScale; 
  1822.   LONG    cStrings; 
  1823.   EMRTEXT aemrtext[1]; 
  1824. } EMRPOLYTEXTOUTA, *PEMRPOLYTEXTOUTA,
  1825.     EMRPOLYTEXTOUTW, *PEMRPOLYTEXTOUTW; 
  1826.  
  1827. typedef struct tagEMRRESIZEPALETTE
  1828. {
  1829.   EMR   emr; 
  1830.   DWORD ihPal; 
  1831.   DWORD cEntries; 
  1832. } EMRRESIZEPALETTE, *PEMRRESIZEPALETTE; 
  1833.  
  1834. typedef struct tagEMRRESTOREDC
  1835. {
  1836.   EMR  emr; 
  1837.   LONG iRelative; 
  1838. } EMRRESTOREDC, *PEMRRESTOREDC; 
  1839.  
  1840. typedef struct tagEMRROUNDRECT
  1841. {
  1842.   EMR   emr; 
  1843.   RECTL rclBox; 
  1844.   SIZEL szlCorner; 
  1845. } EMRROUNDRECT, *PEMRROUNDRECT; 
  1846.  
  1847. typedef struct tagEMRSCALEVIEWPORTEXTEX
  1848. {
  1849.   EMR  emr; 
  1850.   LONG xNum; 
  1851.   LONG xDenom; 
  1852.   LONG yNum; 
  1853.   LONG yDenom; 
  1854. } EMRSCALEVIEWPORTEXTEX, *PEMRSCALEVIEWPORTEXTEX, 
  1855.     EMRSCALEWINDOWEXTEX,   *PEMRSCALEWINDOWEXTEX; 
  1856.  
  1857. typedef struct tagEMRSELECTCOLORSPACE 
  1858. { 
  1859.   EMR     emr; 
  1860.   DWORD   ihCS; 
  1861. } EMRSELECTCOLORSPACE, *PEMRSELECTCOLORSPACE,
  1862.     EMRDELETECOLORSPACE, *PEMRDELETECOLORSPACE; 
  1863. typedef struct tagEMRSELECTOBJECT
  1864. {
  1865.   EMR   emr; 
  1866.   DWORD ihObject;
  1867. } EMRSELECTOBJECT, *PEMRSELECTOBJECT,
  1868.     EMRDELETEOBJECT, *PEMRDELETEOBJECT; 
  1869.  
  1870. typedef struct tagEMRSELECTPALETTE 
  1871. {
  1872.   EMR   emr; 
  1873.   DWORD ihPal; 
  1874. } EMRSELECTPALETTE, *PEMRSELECTPALETTE; 
  1875.  
  1876. typedef struct tagEMRSETARCDIRECTION
  1877. {
  1878.   EMR   emr; 
  1879.   DWORD iArcDirection;
  1880. } EMRSETARCDIRECTION, *PEMRSETARCDIRECTION; 
  1881.  
  1882. typedef struct tagEMRSETTEXTCOLOR
  1883. {
  1884.   EMR      emr; 
  1885.   COLORREF crColor; 
  1886. } EMRSETBKCOLOR,   *PEMRSETBKCOLOR,
  1887.     EMRSETTEXTCOLOR, *PEMRSETTEXTCOLOR; 
  1888.  
  1889. typedef struct tagEMRSETCOLORADJUSTMENT
  1890. {
  1891.   EMR  emr; 
  1892.   COLORADJUSTMENT ColorAdjustment; 
  1893. } EMRSETCOLORADJUSTMENT, *PEMRSETCOLORADJUSTMENT; 
  1894.  
  1895. typedef struct tagEMRSETDIBITSTODEVICE
  1896. {
  1897.   EMR   emr; 
  1898.   RECTL rclBounds; 
  1899.   LONG  xDest; 
  1900.   LONG  yDest; 
  1901.   LONG  xSrc; 
  1902.   LONG  ySrc; 
  1903.   LONG  cxSrc; 
  1904.   LONG  cySrc; 
  1905.   DWORD offBmiSrc; 
  1906.   DWORD cbBmiSrc; 
  1907.   DWORD offBitsSrc; 
  1908.   DWORD cbBitsSrc; 
  1909.   DWORD iUsageSrc; 
  1910.   DWORD iStartScan; 
  1911.   DWORD cScans; 
  1912. } EMRSETDIBITSTODEVICE, *PEMRSETDIBITSTODEVICE; 
  1913.  
  1914. typedef struct tagEMRSETMAPPERFLAGS
  1915. {
  1916.   EMR   emr; 
  1917.   DWORD dwFlags; 
  1918. } EMRSETMAPPERFLAGS, *PEMRSETMAPPERFLAGS; 
  1919.  
  1920. typedef struct tagEMRSETMITERLIMIT
  1921. {
  1922.   EMR   emr;
  1923.   FLOAT eMiterLimit; 
  1924. } EMRSETMITERLIMIT, *PEMRSETMITERLIMIT; 
  1925.  
  1926. typedef struct tagEMRSETPALETTEENTRIES
  1927. {
  1928.   EMR          emr; 
  1929.   DWORD        ihPal; 
  1930.   DWORD        iStart; 
  1931.   DWORD        cEntries; 
  1932.   PALETTEENTRY aPalEntries[1]; 
  1933. } EMRSETPALETTEENTRIES, *PEMRSETPALETTEENTRIES; 
  1934.  
  1935. typedef struct tagEMRSETPIXELV
  1936. {
  1937.   EMR     emr; 
  1938.   POINTL  ptlPixel; 
  1939.   COLORREF crColor; 
  1940. } EMRSETPIXELV, *PEMRSETPIXELV; 
  1941.  
  1942. typedef struct tagEMRSETVIEWPORTEXTEX
  1943. {
  1944.   EMR   emr; 
  1945.   SIZEL szlExtent; 
  1946. } EMRSETVIEWPORTEXTEX, *PEMRSETVIEWPORTEXTEX,
  1947.     EMRSETWINDOWEXTEX,   *PEMRSETWINDOWEXTEX; 
  1948.  
  1949. typedef struct tagEMRSETVIEWPORTORGEX
  1950. {
  1951.   EMR    emr; 
  1952.   POINTL ptlOrigin; 
  1953. } EMRSETVIEWPORTORGEX, *PEMRSETVIEWPORTORGEX,
  1954.     EMRSETWINDOWORGEX,   *PEMRSETWINDOWORGEX,
  1955.     EMRSETBRUSHORGEX,    *PEMRSETBRUSHORGEX; 
  1956.  
  1957. typedef struct tagEMRSETWORLDTRANSFORM
  1958. {
  1959.   EMR   emr; 
  1960.   XFORM xform; 
  1961. } EMRSETWORLDTRANSFORM, *PEMRSETWORLDTRANSFORM; 
  1962.  
  1963. typedef struct tagEMRSTRETCHBLT
  1964. {
  1965.   EMR      emr; 
  1966.   RECTL    rclBounds; 
  1967.   LONG     xDest; 
  1968.   LONG     yDest; 
  1969.   LONG     cxDest; 
  1970.   LONG     cyDest; 
  1971.   DWORD    dwRop; 
  1972.   LONG     xSrc; 
  1973.   LONG     ySrc; 
  1974.   XFORM    xformSrc; 
  1975.   COLORREF crBkColorSrc; 
  1976.   DWORD    iUsageSrc; 
  1977.   DWORD    offBmiSrc; 
  1978.   DWORD    cbBmiSrc; 
  1979.   DWORD    offBitsSrc; 
  1980.   DWORD    cbBitsSrc; 
  1981.   LONG     cxSrc; 
  1982.   LONG     cySrc; 
  1983. } EMRSTRETCHBLT, *PEMRSTRETCHBLT; 
  1984.  
  1985. typedef struct tagEMRSTRETCHDIBITS
  1986. {
  1987.   EMR   emr;
  1988.   RECTL rclBounds; 
  1989.   LONG  xDest; 
  1990.   LONG  yDest; 
  1991.   LONG  xSrc; 
  1992.   LONG  ySrc; 
  1993.   LONG  cxSrc; 
  1994.   LONG  cySrc;
  1995.   DWORD offBmiSrc;
  1996.   DWORD cbBmiSrc; 
  1997.   DWORD offBitsSrc; 
  1998.   DWORD cbBitsSrc; 
  1999.   DWORD iUsageSrc; 
  2000.   DWORD dwRop; 
  2001.   LONG  cxDest; 
  2002.   LONG  cyDest; 
  2003. } EMRSTRETCHDIBITS, *PEMRSTRETCHDIBITS; 
  2004.  
  2005. typedef struct tagABORTPATH 
  2006. { 
  2007.   EMR emr; 
  2008. } EMRABORTPATH,      *PEMRABORTPATH,
  2009.     EMRBEGINPATH,      *PEMRBEGINPATH,
  2010.     EMRENDPATH,        *PEMRENDPATH,
  2011.     EMRCLOSEFIGURE,    *PEMRCLOSEFIGURE,
  2012.     EMRFLATTENPATH,    *PEMRFLATTENPATH,
  2013.     EMRWIDENPATH,      *PEMRWIDENPATH,
  2014.     EMRSETMETARGN,     *PEMRSETMETARGN,
  2015.     EMRSAVEDC,         *PEMRSAVEDC,
  2016.     EMRREALIZEPALETTE, *PEMRREALIZEPALETTE;
  2017.  
  2018. typedef struct tagEMRSELECTCLIPPATH
  2019. {
  2020.   EMR   emr; 
  2021.   DWORD iMode; 
  2022. } EMRSELECTCLIPPATH,    *PEMRSELECTCLIPPATH,
  2023.     EMRSETBKMODE,         *PEMRSETBKMODE,
  2024.     EMRSETMAPMODE,        *PEMRSETMAPMODE,
  2025.     EMRSETPOLYFILLMODE,   *PEMRSETPOLYFILLMODE,
  2026.     EMRSETROP2,           *PEMRSETROP2,
  2027.     EMRSETSTRETCHBLTMODE, *PEMRSETSTRETCHBLTMODE,
  2028.     EMRSETTEXTALIGN,      *PEMRSETTEXTALIGN,
  2029.     EMRENABLEICM,       *PEMRENABLEICM;
  2030.  
  2031. typedef struct tagNMHDR { 
  2032.   HWND hwndFrom; 
  2033.   UINT idFrom; 
  2034.   UINT code; 
  2035. } NMHDR, *PNMHDR, *LPNMHDR; 
  2036.  
  2037. typedef struct _encorrecttext { 
  2038.   NMHDR nmhdr;     
  2039.   CHARRANGE chrg;  
  2040.   WORD seltyp;     
  2041. } ENCORRECTTEXT; 
  2042.  
  2043. typedef struct _endropfiles { 
  2044.   NMHDR nmhdr; 
  2045.   HANDLE hDrop; 
  2046.   LONG cp; 
  2047.   WINBOOL fProtected; 
  2048. } ENDROPFILES; 
  2049.  
  2050. typedef struct {
  2051.   NMHDR nmhdr;        
  2052.   LONG cObjectCount;  
  2053.   LONG cch;           
  2054. } ENSAVECLIPBOARD;
  2055.  
  2056. typedef struct {
  2057.   NMHDR nmhdr;  
  2058.   LONG iob;     
  2059.   LONG lOper;   
  2060.   HRESULT hr;   
  2061. } ENOLEOPFAILED;
  2062.  
  2063. typedef struct tagENHMETAHEADER { 
  2064.   DWORD iType; 
  2065.   DWORD nSize; 
  2066.   RECTL rclBounds; 
  2067.   RECTL rclFrame; 
  2068.   DWORD dSignature; 
  2069.   DWORD nVersion; 
  2070.   DWORD nBytes; 
  2071.   DWORD nRecords; 
  2072.   WORD  nHandles; 
  2073.   WORD  sReserved; 
  2074.   DWORD nDescription; 
  2075.   DWORD offDescription; 
  2076.   DWORD nPalEntries; 
  2077.   SIZEL szlDevice; 
  2078.   SIZEL szlMillimeters; 
  2079. } ENHMETAHEADER, *LPENHMETAHEADER; 
  2080.  
  2081. typedef struct tagENHMETARECORD { 
  2082.   DWORD iType; 
  2083.   DWORD nSize; 
  2084.   DWORD dParm[1]; 
  2085. } ENHMETARECORD, *PENHMETARECORD, *LPENHMETARECORD; 
  2086.  
  2087. typedef struct _enprotected { 
  2088.   NMHDR nmhdr; 
  2089.   UINT msg; 
  2090.   WPARAM wParam; 
  2091.   LPARAM lParam; 
  2092.   CHARRANGE chrg; 
  2093. } ENPROTECTED; 
  2094.  
  2095. typedef struct _SERVICE_STATUS {
  2096.   DWORD dwServiceType; 
  2097.   DWORD dwCurrentState; 
  2098.   DWORD dwControlsAccepted; 
  2099.   DWORD dwWin32ExitCode; 
  2100.   DWORD dwServiceSpecificExitCode; 
  2101.   DWORD dwCheckPoint; 
  2102.   DWORD dwWaitHint; 
  2103. } SERVICE_STATUS, *LPSERVICE_STATUS; 
  2104.  
  2105. typedef struct _ENUM_SERVICE_STATUS { 
  2106.   LPTSTR lpServiceName; 
  2107.   LPTSTR lpDisplayName; 
  2108.   SERVICE_STATUS ServiceStatus; 
  2109. } ENUM_SERVICE_STATUS, *LPENUM_SERVICE_STATUS; 
  2110.  
  2111. typedef struct tagENUMLOGFONT { 
  2112.   LOGFONT elfLogFont; 
  2113.   BCHAR    elfFullName[LF_FULLFACESIZE]; 
  2114.   BCHAR    elfStyle[LF_FACESIZE]; 
  2115. } ENUMLOGFONT; 
  2116.  
  2117. typedef struct tagENUMLOGFONTEX {
  2118.   LOGFONT  elfLogFont;
  2119.   BCHAR  elfFullName[LF_FULLFACESIZE];
  2120.   BCHAR  elfStyle[LF_FACESIZE];
  2121.   BCHAR  elfScript[LF_FACESIZE];
  2122. } ENUMLOGFONTEX;
  2123.  
  2124. typedef struct _EVENTLOGRECORD {
  2125.   DWORD  Length; 
  2126.   DWORD  Reserved; 
  2127.   DWORD  RecordNumber; 
  2128.   DWORD  TimeGenerated; 
  2129.   DWORD  TimeWritten; 
  2130.   DWORD  EventID; 
  2131.   WORD   EventType; 
  2132.   WORD   NumStrings; 
  2133.   WORD   EventCategory; 
  2134.   WORD   ReservedFlags; 
  2135.   DWORD  ClosingRecordNumber; 
  2136.   DWORD  StringOffset; 
  2137.   DWORD  UserSidLength; 
  2138.   DWORD  UserSidOffset; 
  2139.   DWORD  DataLength; 
  2140.   DWORD  DataOffset; 
  2141.  
  2142. /*
  2143.   Then follow: 
  2144.   
  2145.   TCHAR SourceName[] 
  2146.   TCHAR Computername[] 
  2147.   SID   UserSid 
  2148.   TCHAR Strings[] 
  2149.   BYTE  Data[] 
  2150.   CHAR  Pad[] 
  2151.   DWORD Length; 
  2152. */
  2153.   
  2154. } EVENTLOGRECORD; 
  2155.  
  2156. typedef struct tagEVENTMSG {
  2157.   UINT  message; 
  2158.   UINT  paramL; 
  2159.   UINT  paramH; 
  2160.   DWORD time; 
  2161.   HWND  hwnd; 
  2162. } EVENTMSG; 
  2163.  
  2164. typedef struct _EXCEPTION_POINTERS { 
  2165.   PEXCEPTION_RECORD ExceptionRecord; 
  2166.   PCONTEXT ContextRecord; 
  2167. } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS, *LPEXCEPTION_POINTERS; 
  2168.  
  2169. typedef struct _EXT_BUTTON { 
  2170.   WORD idCommand; 
  2171.   WORD idsHelp; 
  2172.   WORD fsStyle; 
  2173. } EXT_BUTTON, *LPEXT_BUTTON; 
  2174.  
  2175. typedef struct tagFILTERKEYS {   
  2176.   UINT  cbSize; 
  2177.   DWORD dwFlags; 
  2178.   DWORD iWaitMSec; 
  2179.   DWORD iDelayMSec; 
  2180.   DWORD iRepeatMSec; 
  2181.   DWORD iBounceMSec; 
  2182. } FILTERKEYS; 
  2183.  
  2184. typedef struct _FIND_NAME_BUFFER { 
  2185.   UCHAR length; 
  2186.   UCHAR access_control; 
  2187.   UCHAR frame_control; 
  2188.   UCHAR destination_addr[6]; 
  2189.   UCHAR source_addr[6]; 
  2190.   UCHAR routing_info[18]; 
  2191. } FIND_NAME_BUFFER; 
  2192.  
  2193. typedef struct _FIND_NAME_HEADER { 
  2194.   WORD  node_count; 
  2195.   UCHAR reserved; 
  2196.   UCHAR unique_group; 
  2197. } FIND_NAME_HEADER; 
  2198.  
  2199. typedef struct {   
  2200.   DWORD        lStructSize; 
  2201.   HWND         hwndOwner; 
  2202.   HINSTANCE    hInstance; 
  2203.   DWORD        Flags; 
  2204.   LPTSTR        lpstrFindWhat; 
  2205.   LPTSTR        lpstrReplaceWith; 
  2206.   WORD         wFindWhatLen; 
  2207.   WORD         wReplaceWithLen; 
  2208.   LPARAM        lCustData; 
  2209.   LPFRHOOKPROC lpfnHook; 
  2210.   LPCTSTR       lpTemplateName; 
  2211. } FINDREPLACE, *LPFINDREPLACE; 
  2212.  
  2213. typedef struct _findtext { 
  2214.   CHARRANGE chrg; 
  2215.   LPSTR lpstrText; 
  2216. } FINDTEXT; 
  2217.  
  2218. typedef struct _findtextex { 
  2219.   CHARRANGE chrg;  
  2220.   LPSTR lpstrText; 
  2221.   CHARRANGE chrgText; 
  2222. } FINDTEXTEX; 
  2223.  
  2224. typedef struct _FMS_GETDRIVEINFO { 
  2225.   DWORD dwTotalSpace; 
  2226.   DWORD dwFreeSpace; 
  2227.   TCHAR  szPath[260]; 
  2228.   TCHAR  szVolume[14]; 
  2229.   TCHAR  szShare[128]; 
  2230. } FMS_GETDRIVEINFO; 
  2231.  
  2232. typedef struct _FMS_GETFILESEL { 
  2233.   FILETIME ftTime; 
  2234.   DWORD    dwSize; 
  2235.   BYTE     bAttr; 
  2236.   TCHAR     szName[260]; 
  2237. } FMS_GETFILESEL; 
  2238.  
  2239. typedef struct _FMS_LOAD { 
  2240.   DWORD dwSize; 
  2241.   TCHAR  szMenuName[MENU_TEXT_LEN]; 
  2242.   HMENU hMenu; 
  2243.   UINT  wMenuDelta; 
  2244. } FMS_LOAD; 
  2245.  
  2246. typedef struct _FMS_TOOLBARLOAD { 
  2247.   DWORD        dwSize; 
  2248.   LPEXT_BUTTON lpButtons; 
  2249.   WORD         cButtons; 
  2250.   WORD         cBitmaps; 
  2251.   WORD         idBitmap; 
  2252.   HBITMAP      hBitmap; 
  2253. } FMS_TOOLBARLOAD; 
  2254.  
  2255. typedef struct _FOCUS_EVENT_RECORD { 
  2256.   WINBOOL bSetFocus; 
  2257. } FOCUS_EVENT_RECORD; 
  2258.  
  2259. typedef struct _FORM_INFO_1 { 
  2260.   DWORD Flags; 
  2261.   LPTSTR pName; 
  2262.   SIZEL  Size; 
  2263.   RECTL  ImageableArea; 
  2264. } FORM_INFO_1; 
  2265.  
  2266. typedef struct _FORMAT_PARAMETERS { 
  2267.   MEDIA_TYPE MediaType; 
  2268.   DWORD StartCylinderNumber; 
  2269.   DWORD EndCylinderNumber; 
  2270.   DWORD StartHeadNumber; 
  2271.   DWORD EndHeadNumber; 
  2272. } FORMAT_PARAMETERS ; 
  2273.  
  2274. typedef struct _formatrange { 
  2275.   HDC hdc; 
  2276.   HDC hdcTarget; 
  2277.   RECT rc; 
  2278.   RECT rcPage; 
  2279.   CHARRANGE chrg; 
  2280. } FORMATRANGE;       
  2281.  
  2282. typedef struct tagGCP_RESULTS {
  2283.   DWORD  lStructSize;
  2284.   LPTSTR  lpOutString;
  2285.   UINT  *lpOrder;
  2286.   INT  *lpDx;
  2287.   INT  *lpCaretPos;
  2288.   LPTSTR lpClass;
  2289.   UINT  *lpGlyphs;
  2290.   UINT  nGlyphs;
  2291.   UINT  nMaxFit;
  2292. } GCP_RESULTS, *LPGCP_RESULTS;
  2293.  
  2294. typedef struct _GENERIC_MAPPING { 
  2295.   ACCESS_MASK GenericRead; 
  2296.   ACCESS_MASK GenericWrite; 
  2297.   ACCESS_MASK GenericExecute; 
  2298.   ACCESS_MASK GenericAll; 
  2299. } GENERIC_MAPPING, *PGENERIC_MAPPING; 
  2300.  
  2301. typedef struct _GLYPHMETRICS { 
  2302.   UINT  gmBlackBoxX; 
  2303.   UINT  gmBlackBoxY; 
  2304.   POINT gmptGlyphOrigin; 
  2305.   short gmCellIncX; 
  2306.   short gmCellIncY; 
  2307. } GLYPHMETRICS, *LPGLYPHMETRICS; 
  2308.  
  2309. typedef struct tagHANDLETABLE { 
  2310.   HGDIOBJ objectHandle[1]; 
  2311. } HANDLETABLE, *LPHANDLETABLE; 
  2312.  
  2313. typedef struct _HD_HITTESTINFO { 
  2314.   POINT pt; 
  2315.   UINT flags; 
  2316.   int iItem; 
  2317. } HD_HITTESTINFO; 
  2318.  
  2319. typedef struct _HD_ITEM { 
  2320.   UINT    mask; 
  2321.   int     cxy; 
  2322.   LPTSTR   pszText; 
  2323.   HBITMAP hbm; 
  2324.   int     cchTextMax; 
  2325.   int     fmt; 
  2326.   LPARAM  lParam; 
  2327. } HD_ITEM; 
  2328.  
  2329. typedef struct _WINDOWPOS { 
  2330.   HWND hwnd; 
  2331.   HWND hwndInsertAfter; 
  2332.   int  x; 
  2333.   int  y; 
  2334.   int  cx; 
  2335.   int  cy; 
  2336.   UINT flags; 
  2337. } WINDOWPOS, *PWINDOWPOS, *LPWINDOWPOS; 
  2338.  
  2339. typedef struct _HD_LAYOUT { 
  2340.   RECT  * prc; 
  2341.   WINDOWPOS  * pwpos; 
  2342. } HD_LAYOUT; 
  2343.  
  2344. typedef struct _HD_NOTIFY { 
  2345.   NMHDR   hdr; 
  2346.   int     iItem; 
  2347.   int     iButton; 
  2348.   HD_ITEM  * pitem; 
  2349. } HD_NOTIFY; 
  2350.  
  2351. typedef  struct  tagHELPINFO { 
  2352.   UINT   cbSize; 
  2353.   int    iContextType; 
  2354.   int    iCtrlId; 
  2355.   HANDLE hItemHandle; 
  2356.   DWORD  dwContextId; 
  2357.   POINT  MousePos; 
  2358. } HELPINFO,   *LPHELPINFO; 
  2359.  
  2360. typedef struct {   
  2361.   int   wStructSize; 
  2362.   int   x; 
  2363.   int   y; 
  2364.   int   dx; 
  2365.   int   dy; 
  2366.   int   wMax; 
  2367.   TCHAR rgchMember[2]; 
  2368. } HELPWININFO; 
  2369.  
  2370. typedef struct tagHIGHCONTRAST {  
  2371.   UINT cbSize; 
  2372.   DWORD dwFlags; 
  2373.   LPTSTR lpszDefaultScheme; 
  2374. } HIGHCONTRAST,  * LPHIGHCONTRAST; 
  2375.  
  2376. typedef struct tagHSZPAIR { 
  2377.   HSZ hszSvc; 
  2378.   HSZ hszTopic; 
  2379. } HSZPAIR; 
  2380.  
  2381. typedef struct _ICONINFO { 
  2382.   WINBOOL    fIcon; 
  2383.   DWORD   xHotspot; 
  2384.   DWORD   yHotspot; 
  2385.   HBITMAP hbmMask; 
  2386.   HBITMAP hbmColor; 
  2387. } ICONINFO, *PICONINFO; 
  2388.  
  2389. typedef struct tagICONMETRICS { 
  2390.   UINT    cbSize; 
  2391.   int     iHorzSpacing; 
  2392.   int     iVertSpacing; 
  2393.   int     iTitleWrap; 
  2394.   LOGFONT lfFont; 
  2395. } ICONMETRICS,   *LPICONMETRICS; 
  2396.  
  2397. typedef struct _IMAGEINFO { 
  2398.   HBITMAP hbmImage; 
  2399.   HBITMAP hbmMask;  
  2400.   int     Unused1;  
  2401.   int     Unused2;  
  2402.   RECT    rcImage;  
  2403. } IMAGEINFO; 
  2404.  
  2405. typedef struct _KEY_EVENT_RECORD { 
  2406.   WINBOOL bKeyDown;             
  2407.   WORD wRepeatCount;         
  2408.   WORD wVirtualKeyCode;      
  2409.   WORD wVirtualScanCode; 
  2410.   union { 
  2411.     WCHAR UnicodeChar; 
  2412.     CHAR  AsciiChar PACKED;
  2413.   } uChar;  
  2414.   DWORD dwControlKeyState;   
  2415. } PACKED KEY_EVENT_RECORD; 
  2416.  
  2417. typedef struct _MOUSE_EVENT_RECORD { 
  2418.   COORD dwMousePosition; 
  2419.   DWORD dwButtonState; 
  2420.   DWORD dwControlKeyState; 
  2421.   DWORD dwEventFlags; 
  2422. } MOUSE_EVENT_RECORD; 
  2423.  
  2424. typedef struct _WINDOW_BUFFER_SIZE_RECORD { 
  2425.   COORD dwSize; 
  2426. } WINDOW_BUFFER_SIZE_RECORD; 
  2427.  
  2428. typedef struct _MENU_EVENT_RECORD { 
  2429.   UINT dwCommandId; 
  2430. } MENU_EVENT_RECORD, *PMENU_EVENT_RECORD; 
  2431.  
  2432. typedef struct _INPUT_RECORD { 
  2433.   WORD EventType; 
  2434.   union { 
  2435.     KEY_EVENT_RECORD KeyEvent; 
  2436.     MOUSE_EVENT_RECORD MouseEvent; 
  2437.     WINDOW_BUFFER_SIZE_RECORD WindowBufferSizeEvent; 
  2438.     MENU_EVENT_RECORD MenuEvent; 
  2439.     FOCUS_EVENT_RECORD FocusEvent; 
  2440.   } Event; 
  2441. } INPUT_RECORD, *PINPUT_RECORD; 
  2442.  
  2443. typedef struct _SYSTEMTIME {  
  2444.   WORD wYear; 
  2445.   WORD wMonth; 
  2446.   WORD wDayOfWeek; 
  2447.   WORD wDay; 
  2448.   WORD wHour; 
  2449.   WORD wMinute; 
  2450.   WORD wSecond; 
  2451.   WORD wMilliseconds; 
  2452. } SYSTEMTIME, *LPSYSTEMTIME; 
  2453.  
  2454. typedef struct _JOB_INFO_1 {  
  2455.   DWORD  JobId; 
  2456.   LPTSTR pPrinterName; 
  2457.   LPTSTR pMachineName; 
  2458.   LPTSTR pUserName; 
  2459.   LPTSTR pDocument; 
  2460.   LPTSTR pDatatype; 
  2461.   LPTSTR pStatus; 
  2462.   DWORD  Status; 
  2463.   DWORD  Priority; 
  2464.   DWORD  Position; 
  2465.   DWORD  TotalPages; 
  2466.   DWORD  PagesPrinted; 
  2467.   SYSTEMTIME Submitted; 
  2468. } JOB_INFO_1; 
  2469.  
  2470. typedef struct _SID_IDENTIFIER_AUTHORITY { 
  2471.   BYTE Value[6]; 
  2472. } SID_IDENTIFIER_AUTHORITY, *PSID_IDENTIFIER_AUTHORITY, 
  2473.     *LPSID_IDENTIFIER_AUTHORITY; 
  2474.  
  2475. typedef struct _SID {
  2476.    BYTE  Revision;
  2477.    BYTE  SubAuthorityCount;
  2478.    SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
  2479.    DWORD SubAuthority[ANYSIZE_ARRAY];
  2480. } SID, *PSID;
  2481.  
  2482. typedef WORD SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
  2483.  
  2484. typedef struct _SECURITY_DESCRIPTOR {
  2485.   BYTE  Revision;
  2486.   BYTE  Sbz1;
  2487.   SECURITY_DESCRIPTOR_CONTROL Control;
  2488.   PSID Owner;
  2489.   PSID Group;
  2490.   PACL Sacl;
  2491.   PACL Dacl;
  2492. } SECURITY_DESCRIPTOR, *PSECURITY_DESCRIPTOR;
  2493.  
  2494. typedef struct _JOB_INFO_2 { 
  2495.   DWORD      JobId; 
  2496.   LPTSTR     pPrinterName; 
  2497.   LPTSTR     pMachineName; 
  2498.   LPTSTR     pUserName; 
  2499.   LPTSTR     pDocument; 
  2500.   LPTSTR     pNotifyName; 
  2501.   LPTSTR     pDatatype; 
  2502.   LPTSTR     pPrintProcessor; 
  2503.   LPTSTR     pParameters; 
  2504.   LPTSTR     pDriverName; 
  2505.   LPDEVMODE  pDevMode; 
  2506.   LPTSTR     pStatus; 
  2507.   PSECURITY_DESCRIPTOR pSecurityDescriptor; 
  2508.   DWORD      Status; 
  2509.   DWORD      Priority; 
  2510.   DWORD      Position; 
  2511.   DWORD      StartTime; 
  2512.   DWORD      UntilTime; 
  2513.   DWORD      TotalPages; 
  2514.   DWORD      Size; 
  2515.   SYSTEMTIME Submitted; 
  2516.   DWORD      Time; 
  2517.   DWORD      PagesPrinted ; 
  2518. } JOB_INFO_2; 
  2519.  
  2520. typedef struct tagKERNINGPAIR { 
  2521.   WORD wFirst; 
  2522.   WORD wSecond; 
  2523.   int  iKernAmount; 
  2524. } KERNINGPAIR, *LPKERNINGPAIR; 
  2525.  
  2526. typedef struct _LANA_ENUM { 
  2527.   UCHAR length; 
  2528.   UCHAR lana[MAX_LANA]; 
  2529. } LANA_ENUM; 
  2530.  
  2531. typedef struct _LDT_ENTRY { 
  2532.   WORD LimitLow; 
  2533.   WORD BaseLow; 
  2534.   union { 
  2535.     struct { 
  2536.       BYTE BaseMid; 
  2537.       BYTE Flags1; 
  2538.       BYTE Flags2; 
  2539.       BYTE BaseHi; 
  2540.     } Bytes; 
  2541.     struct { 
  2542.       DWORD BaseMid : 8; 
  2543.       DWORD Type : 5; 
  2544.       DWORD Dpl : 2; 
  2545.       DWORD Pres : 1; 
  2546.       DWORD LimitHi : 4; 
  2547.       DWORD Sys : 1; 
  2548.       DWORD Reserved_0 : 1; 
  2549.       DWORD Default_Big : 1; 
  2550.       DWORD Granularity : 1; 
  2551.       DWORD BaseHi : 8; 
  2552.     } Bits; 
  2553.   } HighWord; 
  2554. } LDT_ENTRY, *PLDT_ENTRY, *LPLDT_ENTRY; 
  2555.  
  2556. typedef struct tagLOCALESIGNATURE {
  2557.   DWORD  lsUsb[4];
  2558.   DWORD  lsCsbDefault[2];
  2559.   DWORD  lsCsbSupported[2];
  2560. } LOCALESIGNATURE; 
  2561.  
  2562. typedef struct _LOCALGROUP_MEMBERS_INFO_0 {  
  2563.   PSID  lgrmi0_sid; 
  2564. } LOCALGROUP_MEMBERS_INFO_0; 
  2565.  
  2566. typedef struct _LOCALGROUP_MEMBERS_INFO_3 {  
  2567.   LPWSTR  lgrmi3_domainandname; 
  2568. } LOCALGROUP_MEMBERS_INFO_3; 
  2569.  
  2570. typedef long FXPT16DOT16,  * LPFXPT16DOT16; 
  2571.  
  2572. typedef LARGE_INTEGER LUID, *PLUID;
  2573.  
  2574. typedef struct _LUID_AND_ATTRIBUTES { 
  2575.   LUID  Luid; 
  2576.   DWORD Attributes; 
  2577. } LUID_AND_ATTRIBUTES; 
  2578.  
  2579. typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY];
  2580. typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY;
  2581.  
  2582. typedef struct _LV_COLUMN { 
  2583.   UINT mask;       
  2584.   int fmt;         
  2585.   int cx;          
  2586.   LPTSTR pszText;  
  2587.   int cchTextMax;  
  2588.   int iSubItem;    
  2589. } LV_COLUMN; 
  2590.  
  2591. typedef struct _LV_ITEM { 
  2592.   UINT   mask;         
  2593.   int    iItem;        
  2594.   int    iSubItem;     
  2595.   UINT   state;        
  2596.   UINT   stateMask;    
  2597.   LPTSTR  pszText;     
  2598.   int    cchTextMax;   
  2599.   int    iImage;      
  2600.   LPARAM lParam;      
  2601. } LV_ITEM; 
  2602.  
  2603. typedef struct tagLV_DISPINFO { 
  2604.   NMHDR   hdr;   
  2605.   LV_ITEM item;  
  2606. } LV_DISPINFO; 
  2607.  
  2608. typedef struct _LV_FINDINFO { 
  2609.   UINT flags;        
  2610.   LPCTSTR psz;        
  2611.   LPARAM lParam;     
  2612.   POINT pt;          
  2613.   UINT vkDirection;  
  2614. } LV_FINDINFO; 
  2615.  
  2616. typedef struct _LV_HITTESTINFO { 
  2617.   POINT pt;    
  2618.   UINT flags;  
  2619.   int iItem;   
  2620. } LV_HITTESTINFO; 
  2621.  
  2622. typedef struct tagLV_KEYDOWN { 
  2623.   NMHDR hdr;   
  2624.   WORD wVKey;  
  2625.   UINT flags;  
  2626. } LV_KEYDOWN; 
  2627.  
  2628. typedef struct _MAT2 { 
  2629.   FIXED eM11; 
  2630.   FIXED eM12; 
  2631.   FIXED eM21; 
  2632.   FIXED eM22; 
  2633. } MAT2; 
  2634.  
  2635. typedef struct tagMDICREATESTRUCT { 
  2636.   LPCTSTR szClass; 
  2637.   LPCTSTR szTitle; 
  2638.   HANDLE  hOwner; 
  2639.   int     x; 
  2640.   int     y; 
  2641.   int     cx; 
  2642.   int     cy; 
  2643.   DWORD   style; 
  2644.   LPARAM  lParam; 
  2645. } MDICREATESTRUCT; 
  2646.  
  2647. typedef MDICREATESTRUCT *LPMDICREATESTRUCT;
  2648.  
  2649. typedef struct tagMEASUREITEMSTRUCT { 
  2650.   UINT  CtlType;      
  2651.   UINT  CtlID;        
  2652.   UINT  itemID;       
  2653.   UINT  itemWidth;    
  2654.   UINT  itemHeight;   
  2655.   DWORD itemData;     
  2656. } MEASUREITEMSTRUCT, *LPMEASUREITEMSTRUCT; 
  2657.  
  2658. typedef struct _MEMORY_BASIC_INFORMATION { 
  2659.   PVOID BaseAddress;            
  2660.   PVOID AllocationBase;         
  2661.   DWORD AllocationProtect;      
  2662.   DWORD RegionSize;             
  2663.   DWORD State;                  
  2664.   DWORD Protect;                
  2665.   DWORD Type;                   
  2666. } MEMORY_BASIC_INFORMATION; 
  2667. typedef MEMORY_BASIC_INFORMATION *PMEMORY_BASIC_INFORMATION; 
  2668.  
  2669. typedef struct _MEMORYSTATUS { 
  2670.   DWORD dwLength;        
  2671.   DWORD dwMemoryLoad;    
  2672.   DWORD dwTotalPhys;     
  2673.   DWORD dwAvailPhys;     
  2674.   DWORD dwTotalPageFile; 
  2675.   DWORD dwAvailPageFile; 
  2676.   DWORD dwTotalVirtual;  
  2677.   DWORD dwAvailVirtual;  
  2678. } MEMORYSTATUS, *LPMEMORYSTATUS; 
  2679.  
  2680. typedef struct {
  2681.   WORD  wVersion; 
  2682.   WORD  wOffset; 
  2683.   DWORD dwHelpId; 
  2684. } MENUEX_TEMPLATE_HEADER;
  2685.  
  2686. typedef struct { 
  2687.   DWORD  dwType; 
  2688.   DWORD  dwState; 
  2689.   UINT   uId; 
  2690.   BYTE   bResInfo; 
  2691.   WCHAR  szText[1]; 
  2692.   DWORD dwHelpId; 
  2693. } MENUEX_TEMPLATE_ITEM; 
  2694.  
  2695. typedef struct tagMENUITEMINFO {
  2696.   UINT    cbSize; 
  2697.   UINT    fMask; 
  2698.   UINT    fType; 
  2699.   UINT    fState; 
  2700.   UINT    wID; 
  2701.   HMENU   hSubMenu; 
  2702.   HBITMAP hbmpChecked; 
  2703.   HBITMAP hbmpUnchecked; 
  2704.   DWORD   dwItemData; 
  2705.   LPTSTR  dwTypeData; 
  2706.   UINT    cch; 
  2707. } MENUITEMINFO, *LPMENUITEMINFO; 
  2708. typedef MENUITEMINFO CONST *LPCMENUITEMINFO;
  2709.  
  2710. typedef struct {   
  2711.   WORD mtOption;      
  2712.   WORD mtID;          
  2713.   WCHAR mtString[1];  
  2714. } MENUITEMTEMPLATE; 
  2715.  
  2716. typedef struct {      
  2717.   WORD versionNumber; 
  2718.   WORD offset;        
  2719. } MENUITEMTEMPLATEHEADER; 
  2720. typedef VOID MENUTEMPLATE, *LPMENUTEMPLATE;
  2721.  
  2722. typedef struct tagMETAFILEPICT { 
  2723.   LONG      mm; 
  2724.   LONG      xExt; 
  2725.   LONG      yExt; 
  2726.   HMETAFILE hMF; 
  2727. } METAFILEPICT, *PMETAFILEPICT, *LPMETAFILEPICT; 
  2728.  
  2729. typedef struct tagMETAHEADER {  
  2730.   WORD  mtType; 
  2731.   WORD  mtHeaderSize; 
  2732.   WORD  mtVersion; 
  2733.   DWORD mtSize; 
  2734.   WORD  mtNoObjects; 
  2735.   DWORD mtMaxRecord; 
  2736.   WORD  mtNoParameters; 
  2737. } PACKED METAHEADER; 
  2738.  
  2739. typedef struct tagMETARECORD {  
  2740.   DWORD rdSize; 
  2741.   WORD  rdFunction; 
  2742.   WORD  rdParm[1]; 
  2743. } METARECORD, *LPMETARECORD; 
  2744.  
  2745. typedef struct tagMINIMIZEDMETRICS { 
  2746.   UINT    cbSize; 
  2747.   int     iWidth; 
  2748.   int     iHorzGap; 
  2749.   int     iVertGap; 
  2750.   int     iArrange; 
  2751. }   MINIMIZEDMETRICS,   *LPMINIMIZEDMETRICS; 
  2752.  
  2753. typedef struct tagMINMAXINFO {  
  2754.   POINT ptReserved;         
  2755.   POINT ptMaxSize;          
  2756.   POINT ptMaxPosition;      
  2757.   POINT ptMinTrackSize;     
  2758.   POINT ptMaxTrackSize;     
  2759. } MINMAXINFO, *LPMINMAXINFO; 
  2760.  
  2761. typedef struct modemdevcaps_tag {
  2762.   DWORD dwActualSize;           
  2763.   DWORD dwRequiredSize;         
  2764.   DWORD dwDevSpecificOffset;    
  2765.   DWORD dwDevSpecificSize;      
  2766.  
  2767.   DWORD dwModemProviderVersion; 
  2768.   DWORD dwModemManufacturerOffset; 
  2769.   DWORD dwModemManufacturerSize;   
  2770.   DWORD dwModemModelOffset;        
  2771.   DWORD dwModemModelSize;          
  2772.   DWORD dwModemVersionOffset;      
  2773.   DWORD dwModemVersionSize;        
  2774.  
  2775.   DWORD dwDialOptions;             
  2776.   DWORD dwCallSetupFailTimer;      
  2777.   DWORD dwInactivityTimeout;       
  2778.   DWORD dwSpeakerVolume;           
  2779.   DWORD dwSpeakerMode;             
  2780.   DWORD dwModemOptions;            
  2781.   DWORD dwMaxDTERate;              
  2782.   DWORD dwMaxDCERate;              
  2783.  
  2784.   BYTE abVariablePortion [1];    
  2785. } MODEMDEVCAPS, *PMODEMDEVCAPS, *LPMODEMDEVCAPS;
  2786.  
  2787. typedef struct modemsettings_tag {
  2788.   DWORD dwActualSize;            
  2789.   DWORD dwRequiredSize;          
  2790.   DWORD dwDevSpecificOffset;     
  2791.   DWORD dwDevSpecificSize;       
  2792.  
  2793.   DWORD dwCallSetupFailTimer;    
  2794.   DWORD dwInactivityTimeout;     
  2795.   DWORD dwSpeakerVolume;         
  2796.   DWORD dwSpeakerMode;           
  2797.   DWORD dwPreferredModemOptions; 
  2798.  
  2799.   DWORD dwNegotiatedModemOptions; 
  2800.   DWORD dwNegotiatedDCERate;      
  2801.  
  2802.   BYTE  abVariablePortion[1];     
  2803. } MODEMSETTINGS, *PMODEMSETTINGS, *LPMODEMSETTINGS;
  2804.  
  2805. typedef struct tagMONCBSTRUCT { 
  2806.   UINT   cb; 
  2807.   DWORD  dwTime; 
  2808.   HANDLE hTask; 
  2809.   DWORD  dwRet; 
  2810.   UINT   wType; 
  2811.   UINT   wFmt; 
  2812.   HCONV  hConv; 
  2813.   HSZ    hsz1; 
  2814.   HSZ    hsz2; 
  2815.   HDDEDATA hData; 
  2816.   DWORD    dwData1; 
  2817.   DWORD    dwData2; 
  2818.   CONVCONTEXT cc; 
  2819.   DWORD  cbData; 
  2820.   DWORD  Data[8]; 
  2821. } MONCBSTRUCT; 
  2822.  
  2823. typedef struct tagMONCONVSTRUCT { 
  2824.   UINT   cb; 
  2825.   WINBOOL   fConnect; 
  2826.   DWORD  dwTime; 
  2827.   HANDLE hTask; 
  2828.   HSZ    hszSvc; 
  2829.   HSZ    hszTopic; 
  2830.   HCONV  hConvClient; 
  2831.   HCONV  hConvServer; 
  2832. } MONCONVSTRUCT; 
  2833.  
  2834. typedef struct tagMONERRSTRUCT { 
  2835.   UINT   cb; 
  2836.   UINT   wLastError; 
  2837.   DWORD  dwTime; 
  2838.   HANDLE hTask; 
  2839. } MONERRSTRUCT; 
  2840.  
  2841. typedef struct tagMONHSZSTRUCT { 
  2842.   UINT   cb; 
  2843.   WINBOOL   fsAction; 
  2844.   DWORD  dwTime; 
  2845.   HSZ    hsz; 
  2846.   HANDLE hTask; 
  2847.   TCHAR   str[1]; 
  2848. } MONHSZSTRUCT; 
  2849.  
  2850. typedef struct _MONITOR_INFO_1 { 
  2851.   LPTSTR pName; 
  2852. } MONITOR_INFO_1; 
  2853.  
  2854. typedef struct _MONITOR_INFO_2 { 
  2855.   LPTSTR pName; 
  2856.   LPTSTR pEnvironment ; 
  2857.   LPTSTR pDLLName ; 
  2858. } MONITOR_INFO_2; 
  2859.  
  2860. typedef struct tagMONLINKSTRUCT { 
  2861.   UINT   cb; 
  2862.   DWORD  dwTime; 
  2863.   HANDLE hTask; 
  2864.   WINBOOL   fEstablished; 
  2865.   WINBOOL   fNoData; 
  2866.   HSZ    hszSvc; 
  2867.   HSZ    hszTopic; 
  2868.   HSZ    hszItem; 
  2869.   UINT   wFmt; 
  2870.   WINBOOL   fServer; 
  2871.   HCONV  hConvServer; 
  2872.   HCONV  hConvClient; 
  2873. } MONLINKSTRUCT; 
  2874.  
  2875. typedef struct tagMONMSGSTRUCT { 
  2876.   UINT   cb; 
  2877.   HWND   hwndTo; 
  2878.   DWORD  dwTime; 
  2879.   HANDLE hTask; 
  2880.   UINT   wMsg; 
  2881.   WPARAM wParam; 
  2882.   LPARAM lParam; 
  2883.   DDEML_MSG_HOOK_DATA dmhd; 
  2884. } MONMSGSTRUCT; 
  2885.  
  2886. typedef struct tagMOUSEHOOKSTRUCT { 
  2887.   POINT pt; 
  2888.   HWND  hwnd; 
  2889.   UINT  wHitTestCode; 
  2890.   DWORD dwExtraInfo; 
  2891. } MOUSEHOOKSTRUCT, *PMOUSEHOOKSTRUCT, *LPMOUSEHOOKSTRUCT; 
  2892.  
  2893. typedef struct _MOUSEKEYS { 
  2894.   DWORD cbSize; 
  2895.   DWORD dwFlags; 
  2896.   DWORD iMaxSpeed; 
  2897.   DWORD iTimeToMaxSpeed; 
  2898.   DWORD iCtrlSpeed; 
  2899.   DWORD dwReserved1; 
  2900.   DWORD dwReserved2; 
  2901. } MOUSEKEYS; 
  2902.  
  2903. typedef struct tagMSG {  
  2904.   HWND   hwnd;   
  2905.   UINT   message; 
  2906.   WPARAM wParam; 
  2907.   LPARAM lParam; 
  2908.   DWORD  time; 
  2909.   POINT  pt; 
  2910. } MSG, *LPMSG; 
  2911.  
  2912. typedef void CALLBACK (*MSGBOXCALLBACK) (LPHELPINFO lpHelpInfo);
  2913.  
  2914. typedef struct { 
  2915.   UINT      cbSize; 
  2916.   HWND      hwndOwner; 
  2917.   HINSTANCE hInstance; 
  2918.   LPCSTR    lpszText; 
  2919.   LPCSTR    lpszCaption; 
  2920.   DWORD     dwStyle; 
  2921.   LPCSTR    lpszIcon; 
  2922.   DWORD     dwContextHelpId; 
  2923.   MSGBOXCALLBACK lpfnMsgBoxCallback; 
  2924.   DWORD     dwLanguageId; 
  2925. } MSGBOXPARAMS, *PMSGBOXPARAMS,   *LPMSGBOXPARAMS; 
  2926.  
  2927. typedef struct _msgfilter { 
  2928.   NMHDR nmhdr; 
  2929.   UINT msg; 
  2930.   WPARAM wParam; 
  2931.   LPARAM lParam; 
  2932. } MSGFILTER; 
  2933.  
  2934. typedef struct tagMULTIKEYHELP { 
  2935.   DWORD  mkSize; 
  2936.   TCHAR  mkKeylist; 
  2937.   TCHAR  szKeyphrase[1]; 
  2938. } MULTIKEYHELP; 
  2939.  
  2940. typedef struct _NAME_BUFFER { 
  2941.   UCHAR name[NCBNAMSZ]; 
  2942.   UCHAR name_num; 
  2943.   UCHAR name_flags; 
  2944. } NAME_BUFFER; 
  2945.  
  2946. typedef struct _NCB { 
  2947.   UCHAR  ncb_command; 
  2948.   UCHAR  ncb_retcode; 
  2949.   UCHAR  ncb_lsn; 
  2950.   UCHAR  ncb_num; 
  2951.   PUCHAR ncb_buffer; 
  2952.   WORD   ncb_length; 
  2953.   UCHAR  ncb_callname[NCBNAMSZ]; 
  2954.   UCHAR  ncb_name[NCBNAMSZ]; 
  2955.   UCHAR  ncb_rto; 
  2956.   UCHAR  ncb_sto; 
  2957.   void (*ncb_post) (struct _NCB *); 
  2958.   UCHAR  ncb_lana_num; 
  2959.   UCHAR  ncb_cmd_cplt; 
  2960.   UCHAR  ncb_reserve[10]; 
  2961.   HANDLE ncb_event; 
  2962. } NCB; 
  2963.  
  2964. typedef struct _NCCALCSIZE_PARAMS { 
  2965.   RECT        rgrc[3]; 
  2966.   PWINDOWPOS  lppos; 
  2967. } NCCALCSIZE_PARAMS; 
  2968.  
  2969. typedef struct _NDDESHAREINFO { 
  2970.   LONG   lRevision; 
  2971.   LPTSTR lpszShareName; 
  2972.   LONG   lShareType; 
  2973.   LPTSTR lpszAppTopicList; 
  2974.   LONG   fSharedFlag; 
  2975.   LONG   fService; 
  2976.   LONG   fStartAppFlag; 
  2977.   LONG   nCmdShow; 
  2978.   LONG   qModifyId[2]; 
  2979.   LONG   cNumItems; 
  2980.   LPTSTR lpszItemList; 
  2981. }NDDESHAREINFO; 
  2982.  
  2983. typedef struct _NETRESOURCE { 
  2984.   DWORD  dwScope; 
  2985.   DWORD  dwType; 
  2986.   DWORD  dwDisplayType; 
  2987.   DWORD  dwUsage; 
  2988.   LPTSTR lpLocalName; 
  2989.   LPTSTR lpRemoteName; 
  2990.   LPTSTR lpComment; 
  2991.   LPTSTR lpProvider; 
  2992. } NETRESOURCE, *LPNETRESOURCE; 
  2993.  
  2994. typedef struct tagNEWCPLINFO {
  2995.   DWORD dwSize; 
  2996.   DWORD dwFlags; 
  2997.   DWORD dwHelpContext; 
  2998.   LONG  lData; 
  2999.   HICON hIcon; 
  3000.   TCHAR  szName[32]; 
  3001.   TCHAR  szInfo[64]; 
  3002.   TCHAR  szHelpFile[128]; 
  3003. } NEWCPLINFO; 
  3004.  
  3005. typedef struct tagNEWTEXTMETRIC { 
  3006.   LONG   tmHeight; 
  3007.   LONG   tmAscent; 
  3008.   LONG   tmDescent; 
  3009.   LONG   tmInternalLeading; 
  3010.   LONG   tmExternalLeading; 
  3011.   LONG   tmAveCharWidth; 
  3012.   LONG   tmMaxCharWidth; 
  3013.   LONG   tmWeight; 
  3014.   LONG   tmOverhang; 
  3015.   LONG   tmDigitizedAspectX; 
  3016.   LONG   tmDigitizedAspectY; 
  3017.   BCHAR  tmFirstChar; 
  3018.   BCHAR  tmLastChar; 
  3019.   BCHAR  tmDefaultChar; 
  3020.   BCHAR  tmBreakChar; 
  3021.   BYTE   tmItalic; 
  3022.   BYTE   tmUnderlined; 
  3023.   BYTE   tmStruckOut; 
  3024.   BYTE   tmPitchAndFamily; 
  3025.   BYTE   tmCharSet; 
  3026.   DWORD  ntmFlags; 
  3027.   UINT   ntmSizeEM; 
  3028.   UINT   ntmCellHeight; 
  3029.   UINT   ntmAvgWidth; 
  3030. } NEWTEXTMETRIC; 
  3031.  
  3032.  
  3033. typedef struct tagNEWTEXTMETRICEX {
  3034.   NEWTEXTMETRIC  ntmentm;
  3035.   FONTSIGNATURE  ntmeFontSignature;
  3036. } NEWTEXTMETRICEX;
  3037.  
  3038. typedef struct tagNM_LISTVIEW { 
  3039.   NMHDR hdr;        
  3040.   int   iItem;      
  3041.   int   iSubItem;   
  3042.   UINT  uNewState;  
  3043.   UINT  uOldState;  
  3044.   UINT  uChanged;   
  3045.   POINT ptAction;   
  3046.   LPARAM lParam;    
  3047. } NM_LISTVIEW; 
  3048.  
  3049. typedef struct _TREEITEM *HTREEITEM;
  3050.  
  3051. typedef struct _TV_ITEM { 
  3052.   UINT       mask;           
  3053.   HTREEITEM  hItem;           
  3054.   UINT       state;           
  3055.   UINT       stateMask;     
  3056.   LPTSTR     pszText;        
  3057.   int        cchTextMax;      
  3058.   int        iImage;          
  3059.   int        iSelectedImage;  
  3060.   int        cChildren;       
  3061.   LPARAM     lParam;          
  3062. } TV_ITEM,   *LPTV_ITEM; 
  3063.  
  3064. typedef struct _NM_TREEVIEW { 
  3065.   NMHDR    hdr;       
  3066.   UINT     action;        
  3067.   TV_ITEM  itemOld;   
  3068.   TV_ITEM  itemNew;   
  3069.   POINT    ptDrag;    
  3070. } NM_TREEVIEW; 
  3071. typedef NM_TREEVIEW   *LPNM_TREEVIEW; 
  3072.  
  3073. typedef struct _NM_UPDOWN {
  3074.   NMHDR    hdr;    
  3075.   int     iPos;    
  3076.   int  iDelta;     
  3077. } NM_UPDOWNW; 
  3078.  
  3079. typedef struct tagNONCLIENTMETRICS { 
  3080.   UINT    cbSize; 
  3081.   int     iBorderWidth; 
  3082.   int     iScrollWidth; 
  3083.   int     iScrollHeight; 
  3084.   int     iCaptionWidth; 
  3085.   int     iCaptionHeight; 
  3086.   LOGFONT lfCaptionFont; 
  3087.   int     iSmCaptionWidth; 
  3088.   int     iSmCaptionHeight; 
  3089.   LOGFONT lfSmCaptionFont; 
  3090.   int     iMenuWidth; 
  3091.   int     iMenuHeight; 
  3092.   LOGFONT lfMenuFont; 
  3093.   LOGFONT lfStatusFont; 
  3094.   LOGFONT lfMessageFont; 
  3095. } NONCLIENTMETRICS,  * LPNONCLIENTMETRICS; 
  3096.  
  3097. typedef struct _SERVICE_ADDRESS { 
  3098.   DWORD   dwAddressType; 
  3099.   DWORD   dwAddressFlags; 
  3100.   DWORD   dwAddressLength; 
  3101.   DWORD   dwPrincipalLength; 
  3102.   BYTE   *lpAddress;  
  3103.   BYTE   *lpPrincipal; 
  3104. } SERVICE_ADDRESS; 
  3105.  
  3106. typedef struct _SERVICE_ADDRESSES { 
  3107.   DWORD   dwAddressCount; 
  3108.   SERVICE_ADDRESS   Addresses[1]; 
  3109. } SERVICE_ADDRESSES, *LPSERVICE_ADDRESSES; 
  3110.  
  3111. typedef struct _GUID
  3112. { 
  3113.     unsigned long  Data1; 
  3114.     unsigned short  Data2; 
  3115.     unsigned short  Data3; 
  3116.     unsigned char Data4[8]; 
  3117. } GUID, *LPGUID;
  3118. typedef GUID CLSID, *LPCLSID;
  3119.  
  3120. typedef struct _SERVICE_INFO { 
  3121.   LPGUID   lpServiceType; 
  3122.   LPTSTR   lpServiceName; 
  3123.   LPTSTR   lpComment; 
  3124.   LPTSTR   lpLocale; 
  3125.   DWORD    dwDisplayHint; 
  3126.   DWORD    dwVersion; 
  3127.   DWORD    dwTime; 
  3128.   LPTSTR   lpMachineName; 
  3129.   LPSERVICE_ADDRESSES lpServiceAddress; 
  3130.   BLOB ServiceSpecificInfo; 
  3131. } SERVICE_INFO; 
  3132.  
  3133. typedef struct _NS_SERVICE_INFO { 
  3134.   DWORD   dwNameSpace; 
  3135.   SERVICE_INFO ServiceInfo; 
  3136. } NS_SERVICE_INFO; 
  3137.  
  3138. typedef struct _numberfmt { 
  3139.   UINT      NumDigits; 
  3140.   UINT      LeadingZero; 
  3141.   UINT      Grouping; 
  3142.   LPTSTR    lpDecimalSep; 
  3143.   LPTSTR    lpThousandSep; 
  3144.   UINT      NegativeOrder; 
  3145. } NUMBERFMT; 
  3146.  
  3147. typedef struct _OFSTRUCT { 
  3148.   BYTE cBytes; 
  3149.   BYTE fFixedDisk; 
  3150.   WORD nErrCode; 
  3151.   WORD Reserved1; 
  3152.   WORD Reserved2; 
  3153.   CHAR szPathName[OFS_MAXPATHNAME]; 
  3154. } OFSTRUCT, *LPOFSTRUCT; 
  3155.  
  3156. typedef struct tagOFNA { 
  3157.   DWORD         lStructSize; 
  3158.   HWND          hwndOwner; 
  3159.   HINSTANCE     hInstance; 
  3160.   LPCSTR        lpstrFilter; 
  3161.   LPSTR         lpstrCustomFilter; 
  3162.   DWORD         nMaxCustFilter; 
  3163.   DWORD         nFilterIndex; 
  3164.   LPSTR         lpstrFile; 
  3165.   DWORD         nMaxFile; 
  3166.   LPSTR         lpstrFileTitle; 
  3167.   DWORD         nMaxFileTitle; 
  3168.   LPCSTR        lpstrInitialDir; 
  3169.   LPCSTR        lpstrTitle; 
  3170.   DWORD         Flags; 
  3171.   WORD          nFileOffset; 
  3172.   WORD          nFileExtension; 
  3173.   LPCSTR        lpstrDefExt; 
  3174.   DWORD         lCustData; 
  3175.   LPOFNHOOKPROC lpfnHook; 
  3176.   LPCSTR        lpTemplateName; 
  3177. } OPENFILENAMEA, *LPOPENFILENAMEA; 
  3178.  
  3179. typedef struct tagOFNW { 
  3180.   DWORD         lStructSize; 
  3181.   HWND          hwndOwner; 
  3182.   HINSTANCE     hInstance; 
  3183.   LPCWSTR       lpstrFilter; 
  3184.   LPWSTR        lpstrCustomFilter; 
  3185.   DWORD         nMaxCustFilter; 
  3186.   DWORD         nFilterIndex; 
  3187.   LPWSTR        lpstrFile; 
  3188.   DWORD         nMaxFile; 
  3189.   LPWSTR        lpstrFileTitle; 
  3190.   DWORD         nMaxFileTitle; 
  3191.   LPCWSTR       lpstrInitialDir; 
  3192.   LPCWSTR       lpstrTitle; 
  3193.   DWORD         Flags; 
  3194.   WORD          nFileOffset; 
  3195.   WORD          nFileExtension; 
  3196.   LPCWSTR       lpstrDefExt; 
  3197.   DWORD         lCustData; 
  3198.   LPOFNHOOKPROC lpfnHook; 
  3199.   LPCWSTR       lpTemplateName; 
  3200. } OPENFILENAMEW, *LPOPENFILENAMEW; 
  3201.  
  3202. #ifdef    UNICODE
  3203. typedef    OPENFILENAMEW    OPENFILENAME;
  3204. #else
  3205. typedef    OPENFILENAMEA    OPENFILENAME;
  3206. #endif
  3207. typedef    OPENFILENAME    *LPOPENFILENAME;
  3208.  
  3209.  
  3210. typedef struct _OFNOTIFY {
  3211.   NMHDR          hdr; 
  3212.   LPOPENFILENAME lpOFN; 
  3213.   LPTSTR         pszFile; 
  3214. } OFNOTIFY, *LPOFNOTIFY; 
  3215.  
  3216. typedef struct _OSVERSIONINFO { 
  3217.   DWORD dwOSVersionInfoSize; 
  3218.   DWORD dwMajorVersion; 
  3219.   DWORD dwMinorVersion; 
  3220.   DWORD dwBuildNumber; 
  3221.   DWORD dwPlatformId; 
  3222.   TCHAR szCSDVersion[ 128 ]; 
  3223. } OSVERSIONINFO, *POSVERSIONINFO, *LPOSVERSIONINFO; 
  3224.  
  3225. typedef struct tagTEXTMETRIC { 
  3226.   LONG tmHeight; 
  3227.   LONG tmAscent; 
  3228.   LONG tmDescent; 
  3229.   LONG tmInternalLeading; 
  3230.   LONG tmExternalLeading; 
  3231.   LONG tmAveCharWidth; 
  3232.   LONG tmMaxCharWidth; 
  3233.   LONG tmWeight; 
  3234.   LONG tmOverhang; 
  3235.   LONG tmDigitizedAspectX; 
  3236.   LONG tmDigitizedAspectY; 
  3237.   BCHAR tmFirstChar; 
  3238.   BCHAR tmLastChar; 
  3239.   BCHAR tmDefaultChar; 
  3240.   BCHAR tmBreakChar; 
  3241.   BYTE tmItalic; 
  3242.   BYTE tmUnderlined; 
  3243.   BYTE tmStruckOut; 
  3244.   BYTE tmPitchAndFamily; 
  3245.   BYTE tmCharSet; 
  3246. } TEXTMETRIC, *LPTEXTMETRIC; 
  3247.  
  3248. typedef struct _OUTLINETEXTMETRIC { 
  3249.   UINT   otmSize; 
  3250.   TEXTMETRIC otmTextMetrics; 
  3251.   BYTE   otmFiller; 
  3252.   PANOSE otmPanoseNumber; 
  3253.   UINT   otmfsSelection; 
  3254.   UINT   otmfsType; 
  3255.   int    otmsCharSlopeRise; 
  3256.   int    otmsCharSlopeRun; 
  3257.   int    otmItalicAngle; 
  3258.   UINT   otmEMSquare; 
  3259.   int    otmAscent; 
  3260.   int    otmDescent; 
  3261.   UINT   otmLineGap; 
  3262.   UINT   otmsCapEmHeight; 
  3263.   UINT   otmsXHeight; 
  3264.   RECT   otmrcFontBox; 
  3265.   int    otmMacAscent; 
  3266.   int    otmMacDescent; 
  3267.   UINT   otmMacLineGap; 
  3268.   UINT   otmusMinimumPPEM; 
  3269.   POINT  otmptSubscriptSize; 
  3270.   POINT  otmptSubscriptOffset; 
  3271.   POINT  otmptSuperscriptSize; 
  3272.   POINT  otmptSuperscriptOffset; 
  3273.   UINT   otmsStrikeoutSize; 
  3274.   int    otmsStrikeoutPosition; 
  3275.   int    otmsUnderscoreSize; 
  3276.   int    otmsUnderscorePosition; 
  3277.   PSTR   otmpFamilyName; 
  3278.   PSTR   otmpFaceName; 
  3279.   PSTR   otmpStyleName; 
  3280.   PSTR   otmpFullName; 
  3281. } OUTLINETEXTMETRIC, *LPOUTLINETEXTMETRIC; 
  3282.  
  3283. typedef struct _OVERLAPPED { 
  3284.   DWORD  Internal; 
  3285.   DWORD  InternalHigh; 
  3286.   DWORD  Offset; 
  3287.   DWORD  OffsetHigh; 
  3288.   HANDLE hEvent; 
  3289. } OVERLAPPED, *LPOVERLAPPED; 
  3290.  
  3291. typedef struct tagPSD {
  3292.     DWORD           lStructSize; 
  3293.     HWND            hwndOwner; 
  3294.     HGLOBAL         hDevMode; 
  3295.     HGLOBAL         hDevNames; 
  3296.     DWORD           Flags; 
  3297.     POINT           ptPaperSize; 
  3298.     RECT            rtMinMargin; 
  3299.     RECT            rtMargin; 
  3300.     HINSTANCE       hInstance; 
  3301.     LPARAM          lCustData; 
  3302.     LPPAGESETUPHOOK lpfnPageSetupHook; 
  3303.     LPPAGEPAINTHOOK lpfnPagePaintHook; 
  3304.     LPCTSTR         lpPageSetupTemplateName; 
  3305.     HGLOBAL         hPageSetupTemplate; 
  3306. } PAGESETUPDLG, *LPPAGESETUPDLG; 
  3307.  
  3308. typedef struct tagPAINTSTRUCT { 
  3309.   HDC  hdc; 
  3310.   WINBOOL fErase; 
  3311.   RECT rcPaint; 
  3312.   WINBOOL fRestore; 
  3313.   WINBOOL fIncUpdate; 
  3314.   BYTE rgbReserved[32]; 
  3315. } PAINTSTRUCT, *LPPAINTSTRUCT; 
  3316.  
  3317. typedef struct _paraformat { 
  3318.   UINT cbSize; 
  3319.   DWORD dwMask; 
  3320.   WORD  wNumbering; 
  3321.   WORD  wReserved; 
  3322.   LONG  dxStartIndent; 
  3323.   LONG  dxRightIndent; 
  3324.   LONG  dxOffset; 
  3325.   WORD  wAlignment; 
  3326.   SHORT cTabCount; 
  3327.   LONG  rgxTabs[MAX_TAB_STOPS]; 
  3328. } PARAFORMAT; 
  3329.  
  3330. typedef struct _PERF_COUNTER_BLOCK { 
  3331.   DWORD ByteLength; 
  3332. } PERF_COUNTER_BLOCK; 
  3333.  
  3334. typedef struct _PERF_COUNTER_DEFINITION { 
  3335.   DWORD  ByteLength; 
  3336.   DWORD  CounterNameTitleIndex; 
  3337.   LPWSTR CounterNameTitle; 
  3338.   DWORD  CounterHelpTitleIndex; 
  3339.   LPWSTR CounterHelpTitle; 
  3340.   DWORD  DefaultScale; 
  3341.   DWORD  DetailLevel; 
  3342.   DWORD  CounterType; 
  3343.   DWORD  CounterSize; 
  3344.   DWORD  CounterOffset; 
  3345. } PERF_COUNTER_DEFINITION; 
  3346.  
  3347. typedef struct _PERF_DATA_BLOCK { 
  3348.   WCHAR         Signature[4]; 
  3349.   DWORD         LittleEndian; 
  3350.   DWORD         Version; 
  3351.   DWORD         Revision; 
  3352.   DWORD         TotalByteLength; 
  3353.   DWORD         HeaderLength; 
  3354.   DWORD         NumObjectTypes; 
  3355.   DWORD         DefaultObject; 
  3356.   SYSTEMTIME    SystemTime; 
  3357.   LARGE_INTEGER PerfTime; 
  3358.   LARGE_INTEGER PerfFreq; 
  3359.   LARGE_INTEGER PerfTime100nSec; 
  3360.   DWORD         SystemNameLength; 
  3361.   DWORD         SystemNameOffset; 
  3362. } PERF_DATA_BLOCK; 
  3363.  
  3364. typedef struct _PERF_INSTANCE_DEFINITION { 
  3365.   DWORD ByteLength; 
  3366.   DWORD ParentObjectTitleIndex; 
  3367.   DWORD ParentObjectInstance; 
  3368.   DWORD UniqueID; 
  3369.   DWORD NameOffset; 
  3370.   DWORD NameLength; 
  3371. } PERF_INSTANCE_DEFINITION; 
  3372.  
  3373. typedef struct _PERF_OBJECT_TYPE { 
  3374.   DWORD  TotalByteLength; 
  3375.   DWORD  DefinitionLength; 
  3376.   DWORD  HeaderLength; 
  3377.   DWORD  ObjectNameTitleIndex; 
  3378.   LPWSTR ObjectNameTitle; 
  3379.   DWORD  ObjectHelpTitleIndex; 
  3380.   LPWSTR ObjectHelpTitle; 
  3381.   DWORD  DetailLevel; 
  3382.   DWORD  NumCounters; 
  3383.   DWORD  DefaultCounter; 
  3384.   DWORD  NumInstances; 
  3385.   DWORD  CodePage; 
  3386.   LARGE_INTEGER PerfTime; 
  3387.   LARGE_INTEGER PerfFreq; 
  3388. } PERF_OBJECT_TYPE; 
  3389.  
  3390. typedef struct _POLYTEXT { 
  3391.   int     x; 
  3392.   int     y; 
  3393.   UINT    n; 
  3394.   LPCTSTR lpstr; 
  3395.   UINT    uiFlags; 
  3396.   RECT    rcl; 
  3397.   int     *pdx; 
  3398. } POLYTEXT; 
  3399.  
  3400. typedef struct _PORT_INFO_1 { 
  3401.   LPTSTR pName; 
  3402. } PORT_INFO_1; 
  3403.  
  3404. typedef struct _PORT_INFO_2 { 
  3405.   LPSTR pPortName; 
  3406.   LPSTR pMonitorName; 
  3407.   LPSTR pDescription; 
  3408.   DWORD fPortType; 
  3409.   DWORD Reserved; 
  3410. } PORT_INFO_2; 
  3411.  
  3412. typedef struct _PREVENT_MEDIA_REMOVAL { 
  3413.   BOOLEAN PreventMediaRemoval; 
  3414. } PREVENT_MEDIA_REMOVAL ; 
  3415.  
  3416. typedef struct tagPD {  
  3417.   DWORD     lStructSize; 
  3418.   HWND      hwndOwner; 
  3419.   HANDLE    hDevMode; 
  3420.   HANDLE    hDevNames; 
  3421.   HDC       hDC; 
  3422.   DWORD     Flags; 
  3423.   WORD      nFromPage; 
  3424.   WORD      nToPage; 
  3425.   WORD      nMinPage; 
  3426.   WORD      nMaxPage; 
  3427.   WORD      nCopies; 
  3428.   HINSTANCE hInstance; 
  3429.   DWORD     lCustData; 
  3430.   LPPRINTHOOKPROC lpfnPrintHook; 
  3431.   LPSETUPHOOKPROC lpfnSetupHook; 
  3432.   LPCTSTR    lpPrintTemplateName; 
  3433.   LPCTSTR    lpSetupTemplateName; 
  3434.   HANDLE    hPrintTemplate; 
  3435.   HANDLE    hSetupTemplate; 
  3436. } PACKED PRINTDLG, *LPPRINTDLG; 
  3437.  
  3438. typedef struct _PRINTER_DEFAULTS {  
  3439.   LPTSTR      pDatatype; 
  3440.   LPDEVMODE   pDevMode; 
  3441.   ACCESS_MASK DesiredAccess; 
  3442. } PRINTER_DEFAULTS, *PPRINTER_DEFAULTS, *LPPRINTER_DEFAULTS; 
  3443.  
  3444. #ifdef UNICODE
  3445. typedef PRINTER_DEFAULTS PRINTER_DEFAULTSW;
  3446. typedef PPRINTER_DEFAULTS PPRINTER_DEFAULTSW;
  3447. typedef LPPRINTER_DEFAULTS LPPRINTER_DEFAULTSW;
  3448. #else
  3449. typedef PRINTER_DEFAULTS PRINTER_DEFAULTSA;
  3450. typedef PPRINTER_DEFAULTS PPRINTER_DEFAULTSA;
  3451. typedef LPPRINTER_DEFAULTS LPPRINTER_DEFAULTSA;
  3452. #endif /* UNICODE */
  3453.  
  3454. typedef struct _PRINTER_INFO_1 { 
  3455.   DWORD  Flags; 
  3456.   LPTSTR pDescription; 
  3457.   LPTSTR pName; 
  3458.   LPTSTR pComment; 
  3459. } PRINTER_INFO_1, *PPRINTER_INFO_1, *LPPRINTER_INFO_1; 
  3460.  
  3461. typedef struct _PRINTER_INFO_2 { 
  3462.   LPTSTR    pServerName; 
  3463.   LPTSTR    pPrinterName; 
  3464.   LPTSTR    pShareName; 
  3465.   LPTSTR    pPortName; 
  3466.   LPTSTR    pDriverName; 
  3467.   LPTSTR    pComment; 
  3468.   LPTSTR    pLocation; 
  3469.   LPDEVMODE pDevMode; 
  3470.   LPTSTR    pSepFile; 
  3471.   LPTSTR    pPrintProcessor; 
  3472.   LPTSTR    pDatatype; 
  3473.   LPTSTR    pParameters; 
  3474.   PSECURITY_DESCRIPTOR pSecurityDescriptor; 
  3475.   DWORD     Attributes; 
  3476.   DWORD     Priority; 
  3477.   DWORD     DefaultPriority; 
  3478.   DWORD     StartTime; 
  3479.   DWORD     UntilTime; 
  3480.   DWORD     Status; 
  3481.   DWORD     cJobs; 
  3482.   DWORD     AveragePPM; 
  3483. } PRINTER_INFO_2; 
  3484.  
  3485. typedef struct _PRINTER_INFO_3 { 
  3486.   PSECURITY_DESCRIPTOR pSecurityDescriptor; 
  3487. } PRINTER_INFO_3; 
  3488.  
  3489. typedef struct _PRINTER_INFO_4 { 
  3490.   LPTSTR  pPrinterName; 
  3491.   LPTSTR  pServerName; 
  3492.   DWORD  Attributes; 
  3493. } PRINTER_INFO_4; 
  3494.  
  3495. typedef struct _PRINTER_INFO_5 { 
  3496.   LPTSTR    pPrinterName; 
  3497.   LPTSTR    pPortName; 
  3498.   DWORD     Attributes; 
  3499.   DWORD     DeviceNotSelectedTimeout; 
  3500.   DWORD     TransmissionRetryTimeout; 
  3501. } PRINTER_INFO_5; 
  3502.  
  3503. typedef struct _PRINTER_NOTIFY_INFO_DATA { 
  3504.   WORD   Type; 
  3505.   WORD   Field; 
  3506.   DWORD  Reserved; 
  3507.   DWORD  Id; 
  3508.   union { 
  3509.     DWORD  adwData[2]; 
  3510.     struct { 
  3511.       DWORD  cbBuf; 
  3512.       LPVOID pBuf; 
  3513.     } Data; 
  3514.   } NotifyData; 
  3515. } PRINTER_NOTIFY_INFO_DATA; 
  3516.  
  3517. typedef struct _PRINTER_NOTIFY_INFO { 
  3518.   DWORD  Version; 
  3519.   DWORD  Flags; 
  3520.   DWORD  Count; 
  3521.   PRINTER_NOTIFY_INFO_DATA  aData[1]; 
  3522. } PRINTER_NOTIFY_INFO; 
  3523.  
  3524. typedef struct _PRINTER_NOTIFY_OPTIONS_TYPE { 
  3525.   WORD   Type; 
  3526.   WORD   Reserved0; 
  3527.   DWORD  Reserved1; 
  3528.   DWORD  Reserved2; 
  3529.   DWORD  Count; 
  3530.   PWORD  pFields; 
  3531. } PRINTER_NOTIFY_OPTIONS_TYPE, *PPRINTER_NOTIFY_OPTIONS_TYPE; 
  3532.  
  3533. typedef struct _PRINTER_NOTIFY_OPTIONS { 
  3534.   DWORD  Version; 
  3535.   DWORD  Flags; 
  3536.   DWORD  Count; 
  3537.   PPRINTER_NOTIFY_OPTIONS_TYPE  pTypes; 
  3538. } PRINTER_NOTIFY_OPTIONS; 
  3539.  
  3540. typedef struct _PRINTPROCESSOR_INFO_1 { 
  3541.   LPTSTR pName; 
  3542. } PRINTPROCESSOR_INFO_1; 
  3543.  
  3544. typedef struct _PRIVILEGE_SET { 
  3545.   DWORD PrivilegeCount; 
  3546.   DWORD Control; 
  3547.   LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY]; 
  3548. } PRIVILEGE_SET, *PPRIVILEGE_SET, *LPPRIVILEGE_SET; 
  3549.  
  3550. typedef struct _PROCESS_HEAP_ENTRY {  
  3551.   PVOID lpData; 
  3552.   DWORD cbData; 
  3553.   BYTE cbOverhead; 
  3554.   BYTE iRegionIndex; 
  3555.   WORD wFlags; 
  3556.   DWORD dwCommittedSize; 
  3557.   DWORD dwUnCommittedSize; 
  3558.   LPVOID lpFirstBlock; 
  3559.   LPVOID lpLastBlock; 
  3560.   HANDLE hMem; 
  3561. } PROCESS_HEAPENTRY, *LPPROCESS_HEAP_ENTRY; 
  3562.  
  3563. typedef struct _PROCESS_INFORMATION { 
  3564.   HANDLE hProcess; 
  3565.   HANDLE hThread; 
  3566.   DWORD dwProcessId; 
  3567.   DWORD dwThreadId; 
  3568. } PROCESS_INFORMATION, *LPPROCESS_INFORMATION; 
  3569.  
  3570. typedef UINT CALLBACK (*LPFNPSPCALLBACK) (HWND, UINT, LPVOID);
  3571.  
  3572. typedef struct _PROPSHEETPAGE { 
  3573.   DWORD     dwSize;     
  3574.   DWORD     dwFlags;    
  3575.   HINSTANCE hInstance;  
  3576.   union { 
  3577.     LPCTSTR        pszTemplate;      
  3578.     LPCDLGTEMPLATE pResource;        
  3579.   } u1; 
  3580.   union { 
  3581.     HICON  hIcon;     
  3582.     LPCTSTR pszIcon;  
  3583.   } u2; 
  3584.   LPCTSTR pszTitle;     
  3585.   DLGPROC pfnDlgProc;   
  3586.   LPARAM  lParam;       
  3587.   LPFNPSPCALLBACK pfnCallback;         
  3588.   UINT   * pcRefParent;              
  3589. } PROPSHEETPAGE,   *LPPROPSHEETPAGE; 
  3590. typedef const PROPSHEETPAGE   *LPCPROPSHEETPAGE; 
  3591.  
  3592. typedef struct _PSP *HPROPSHEETPAGE;
  3593. typedef struct _PROPSHEETHEADER { 
  3594.   DWORD      dwSize;     
  3595.   DWORD      dwFlags;    
  3596.   HWND       hwndParent; 
  3597.   HINSTANCE  hInstance;  
  3598.   union { 
  3599.     HICON  hIcon;      
  3600.     LPCTSTR pszIcon;   
  3601.   } u1; 
  3602.   LPCTSTR     pszCaption; 
  3603.   UINT       nPages; 
  3604.   union { 
  3605.     UINT  nStartPage; 
  3606.     LPCTSTR pStartPage; 
  3607.   } u2; 
  3608.   union { 
  3609.     LPCPROPSHEETPAGE    ppsp;   
  3610.     HPROPSHEETPAGE   *phpage; 
  3611.   } u3; 
  3612.   PFNPROPSHEETCALLBACK pfnCallback; 
  3613. } PROPSHEETHEADER,   *LPPROPSHEETHEADER; 
  3614. typedef const PROPSHEETHEADER   *LPCPROPSHEETHEADER; 
  3615.  
  3616. /* PropertySheet callbacks */
  3617. typedef WINBOOL CALLBACK (*LPFNADDPROPSHEETPAGE) (HPROPSHEETPAGE, LPARAM);
  3618. typedef WINBOOL CALLBACK (*LPFNADDPROPSHEETPAGES) (LPVOID, 
  3619.                            LPFNADDPROPSHEETPAGE, 
  3620.                            LPARAM);
  3621.  
  3622. typedef  struct _PROTOCOL_INFO {  
  3623.   DWORD  dwServiceFlags; 
  3624.   INT  iAddressFamily; 
  3625.   INT  iMaxSockAddr; 
  3626.   INT  iMinSockAddr; 
  3627.   INT  iSocketType; 
  3628.   INT  iProtocol; 
  3629.   DWORD  dwMessageSize; 
  3630.   LPTSTR  lpProtocol; 
  3631. } PROTOCOL_INFO; 
  3632.  
  3633. typedef struct _PROVIDOR_INFO_1 { 
  3634.   LPTSTR pName; 
  3635.   LPTSTR pEnvironment ; 
  3636.   LPTSTR pDLLName ; 
  3637. } PROVIDOR_INFO_1; 
  3638.  
  3639. typedef struct _PSHNOTIFY { 
  3640.   NMHDR hdr; 
  3641.   LPARAM lParam; 
  3642. } PSHNOTIFY,   *LPPSHNOTIFY; 
  3643.  
  3644. typedef struct _punctuation {
  3645.   UINT   iSize;          
  3646.   LPSTR  szPunctuation;  
  3647. } PUNCTUATION; 
  3648.  
  3649. typedef struct _QUERY_SERVICE_CONFIG { 
  3650.   DWORD dwServiceType; 
  3651.   DWORD dwStartType; 
  3652.   DWORD dwErrorControl; 
  3653.   LPTSTR lpBinaryPathName; 
  3654.   LPTSTR lpLoadOrderGroup; 
  3655.   DWORD dwTagId; 
  3656.   LPTSTR lpDependencies; 
  3657.   LPTSTR lpServiceStartName; 
  3658.   LPTSTR lpDisplayName; 
  3659. } QUERY_SERVICE_CONFIG, *LPQUERY_SERVICE_CONFIG; 
  3660.  
  3661. typedef struct _QUERY_SERVICE_LOCK_STATUS { 
  3662.   DWORD fIsLocked; 
  3663.   LPTSTR lpLockOwner; 
  3664.   DWORD dwLockDuration; 
  3665. } QUERY_SERVICE_LOCK_STATUS, *LPQUERY_SERVICE_LOCK_STATUS ; 
  3666.  
  3667. typedef  struct  _RASAMB {  
  3668.   DWORD    dwSize; 
  3669.   DWORD    dwError; 
  3670.   TCHAR    szNetBiosError[ NETBIOS_NAME_LEN + 1 ]; 
  3671.   BYTE     bLana; 
  3672. } RASAMB; 
  3673.  
  3674. typedef struct _RASCONN { 
  3675.   DWORD     dwSize; 
  3676.   HRASCONN  hrasconn; 
  3677.   TCHAR     szEntryName[RAS_MaxEntryName + 1]; 
  3678.  
  3679.   CHAR      szDeviceType[ RAS_MaxDeviceType + 1 ]; 
  3680.   CHAR      szDeviceName[ RAS_MaxDeviceName + 1 ]; 
  3681. } RASCONN ; 
  3682.  
  3683. typedef struct _RASCONNSTATUS { 
  3684.   DWORD         dwSize; 
  3685.   RASCONNSTATE  rasconnstate; 
  3686.   DWORD         dwError; 
  3687.   TCHAR         szDeviceType[RAS_MaxDeviceType + 1]; 
  3688.   TCHAR         szDeviceName[RAS_MaxDeviceName + 1]; 
  3689. } RASCONNSTATUS; 
  3690.  
  3691. typedef  struct  _RASDIALEXTENSIONS { 
  3692.   DWORD    dwSize; 
  3693.   DWORD    dwfOptions; 
  3694.   HWND    hwndParent; 
  3695.   DWORD    reserved; 
  3696. } RASDIALEXTENSIONS; 
  3697.  
  3698. typedef struct _RASDIALPARAMS { 
  3699.   DWORD  dwSize; 
  3700.   TCHAR  szEntryName[RAS_MaxEntryName + 1]; 
  3701.   TCHAR  szPhoneNumber[RAS_MaxPhoneNumber + 1]; 
  3702.   TCHAR  szCallbackNumber[RAS_MaxCallbackNumber + 1]; 
  3703.   TCHAR  szUserName[UNLEN + 1]; 
  3704.   TCHAR  szPassword[PWLEN + 1]; 
  3705.   TCHAR  szDomain[DNLEN + 1] ; 
  3706. } RASDIALPARAMS; 
  3707.  
  3708. typedef struct _RASENTRYNAME { 
  3709.   DWORD  dwSize; 
  3710.   TCHAR  szEntryName[RAS_MaxEntryName + 1]; 
  3711. }RASENTRYNAME; 
  3712.  
  3713. typedef  struct  _RASPPPIP { 
  3714.   DWORD    dwSize; 
  3715.   DWORD    dwError; 
  3716.   TCHAR    szIpAddress[ RAS_MaxIpAddress + 1 ]; 
  3717. } RASPPPIP; 
  3718.  
  3719. typedef  struct  _RASPPPIPX { 
  3720.   DWORD    dwSize; 
  3721.   DWORD    dwError; 
  3722.   TCHAR    szIpxAddress[ RAS_MaxIpxAddress + 1 ]; 
  3723. } RASPPPIPX; 
  3724.  
  3725. typedef  struct  _RASPPPNBF { 
  3726.   DWORD    dwSize; 
  3727.   DWORD    dwError; 
  3728.   DWORD    dwNetBiosError; 
  3729.   TCHAR    szNetBiosError[ NETBIOS_NAME_LEN + 1 ]; 
  3730.   TCHAR    szWorkstationName[ NETBIOS_NAME_LEN + 1 ]; 
  3731.   BYTE     bLana; 
  3732. } RASPPPNBF; 
  3733.  
  3734. typedef struct _RASTERIZER_STATUS { 
  3735.   short nSize; 
  3736.   short wFlags; 
  3737.   short nLanguageID; 
  3738. } RASTERIZER_STATUS, *LPRASTERIZER_STATUS; 
  3739.  
  3740. typedef struct _REASSIGN_BLOCKS { 
  3741.   WORD   Reserved; 
  3742.   WORD   Count; 
  3743.   DWORD BlockNumber[1]; 
  3744. } REASSIGN_BLOCKS ; 
  3745.  
  3746. typedef struct _REMOTE_NAME_INFO {
  3747.   LPTSTR  lpUniversalName; 
  3748.   LPTSTR  lpConnectionName; 
  3749.   LPTSTR  lpRemainingPath;    
  3750. } REMOTE_NAME_INFO; 
  3751.  
  3752. /*
  3753.  TODO: OLE
  3754. typedef struct _reobject { 
  3755.   DWORD  cbStruct;           
  3756.   LONG   cp;                 
  3757.   CLSID  clsid;              
  3758.   LPOLEOBJECT      poleobj;  
  3759.   LPSTORAGE        pstg;     
  3760.   LPOLECLIENTSITE  polesite; 
  3761.   SIZEL  sizel;              
  3762.   DWORD  dvaspect;           
  3763.   DWORD  dwFlags;            
  3764.   DWORD  dwUser;             
  3765. } REOBJECT; 
  3766. */
  3767.  
  3768. typedef struct _repastespecial { 
  3769.   DWORD  dwAspect;  
  3770.   DWORD  dwParam;   
  3771. } REPASTESPECIAL; 
  3772.  
  3773. typedef struct _reqresize { 
  3774.   NMHDR nmhdr; 
  3775.   RECT rc; 
  3776. } REQRESIZE; 
  3777.  
  3778. typedef struct _RGNDATAHEADER { 
  3779.   DWORD dwSize; 
  3780.   DWORD iType; 
  3781.   DWORD nCount; 
  3782.   DWORD nRgnSize; 
  3783.   RECT  rcBound; 
  3784. } RGNDATAHEADER; 
  3785.  
  3786. typedef struct _RGNDATA { 
  3787.   RGNDATAHEADER rdh; 
  3788.   char          Buffer[1]; 
  3789. } RGNDATA, *LPRGNDATA; 
  3790.  
  3791. typedef struct tagSCROLLINFO {
  3792.   UINT cbSize; 
  3793.   UINT fMask; 
  3794.   int  nMin; 
  3795.   int  nMax; 
  3796.   UINT nPage; 
  3797.   int  nPos; 
  3798.   int  nTrackPos; 
  3799. }   SCROLLINFO, *LPSCROLLINFO; 
  3800. typedef SCROLLINFO const *LPCSCROLLINFO; 
  3801.  
  3802. typedef struct _SECURITY_ATTRIBUTES { 
  3803.   DWORD  nLength; 
  3804.   LPVOID lpSecurityDescriptor; 
  3805.   WINBOOL   bInheritHandle; 
  3806. } SECURITY_ATTRIBUTES, *LPSECURITY_ATTRIBUTES; 
  3807.  
  3808. typedef DWORD SECURITY_INFORMATION, *PSECURITY_INFORMATION; 
  3809.  
  3810. typedef struct _selchange { 
  3811.   NMHDR nmhdr; 
  3812.   CHARRANGE chrg; 
  3813.   WORD seltyp; 
  3814. } SELCHANGE; 
  3815.  
  3816. typedef struct tagSERIALKEYS {  
  3817.   DWORD cbSize; 
  3818.   DWORD dwFlags; 
  3819.   LPSTR lpszActivePort; 
  3820.   LPSTR lpszPort; 
  3821.   DWORD iBaudRate; 
  3822.   DWORD iPortState; 
  3823. } SERIALKEYS,  * LPSERIALKEYS; 
  3824.  
  3825. typedef struct _SERVICE_TABLE_ENTRY { 
  3826.   LPTSTR lpServiceName; 
  3827.   LPSERVICE_MAIN_FUNCTION lpServiceProc; 
  3828. } SERVICE_TABLE_ENTRY, *LPSERVICE_TABLE_ENTRY; 
  3829.  
  3830. typedef struct _SERVICE_TYPE_VALUE_ABS { 
  3831.   DWORD   dwNameSpace; 
  3832.   DWORD   dwValueType; 
  3833.   DWORD   dwValueSize; 
  3834.   LPTSTR  lpValueName; 
  3835.   PVOID   lpValue; 
  3836. } SERVICE_TYPE_VALUE_ABS; 
  3837.  
  3838. typedef struct _SERVICE_TYPE_INFO_ABS { 
  3839.   LPTSTR                  lpTypeName; 
  3840.   DWORD                   dwValueCount; 
  3841.   SERVICE_TYPE_VALUE_ABS  Values[1]; 
  3842. } SERVICE_TYPE_INFO_ABS; 
  3843.  
  3844. typedef struct _SESSION_BUFFER { 
  3845.   UCHAR lsn; 
  3846.   UCHAR state; 
  3847.   UCHAR local_name[NCBNAMSZ]; 
  3848.   UCHAR remote_name[NCBNAMSZ]; 
  3849.   UCHAR rcvs_outstanding; 
  3850.   UCHAR sends_outstanding; 
  3851. } SESSION_BUFFER; 
  3852.  
  3853. typedef struct _SESSION_HEADER { 
  3854.   UCHAR sess_name; 
  3855.   UCHAR num_sess; 
  3856.   UCHAR rcv_dg_outstanding; 
  3857.   UCHAR rcv_any_outstanding; 
  3858. } SESSION_HEADER; 
  3859.  
  3860. typedef struct _SET_PARTITION_INFORMATION { 
  3861.   BYTE PartitionType; 
  3862. } SET_PARTITION_INFORMATION ; 
  3863.  
  3864. typedef enum tagSHCONTF { 
  3865.   SHCONTF_FOLDERS = 32,         
  3866.   SHCONTF_NONFOLDERS = 64,      
  3867.   SHCONTF_INCLUDEHIDDEN = 128
  3868. } SHCONTF; 
  3869.  
  3870. typedef struct _SHFILEINFO { 
  3871.   HICON hIcon;                   
  3872.   int   iIcon;                   
  3873.   DWORD dwAttributes;            
  3874.   char  szDisplayName[MAX_PATH]; 
  3875.   char  szTypeName[80];          
  3876. } SHFILEINFO; 
  3877.  
  3878. typedef WORD FILEOP_FLAGS; 
  3879. typedef struct _SHFILEOPSTRUCT { 
  3880.   HWND         hwnd;                  
  3881.   UINT         wFunc;                 
  3882.   LPCSTR       pFrom;                 
  3883.   LPCSTR       pTo;                   
  3884.   FILEOP_FLAGS fFlags;                
  3885.   WINBOOL         fAnyOperationsAborted; 
  3886.   LPVOID       hNameMappings;         
  3887.   LPCSTR       lpszProgressTitle;     
  3888. } SHFILEOPSTRUCT,   *LPSHFILEOPSTRUCT; 
  3889.  
  3890. typedef enum tagSHGDN {
  3891.   SHGDN_NORMAL = 0, 
  3892.   SHGDN_INFOLDER = 1, 
  3893.   SHGDN_FORPARSING = 0x8000
  3894. } SHGNO; 
  3895.  
  3896. typedef struct _SHNAMEMAPPING { 
  3897.   LPSTR pszOldPath; 
  3898.   LPSTR pszNewPath; 
  3899.   int   cchOldPath; 
  3900.   int   cchNewPath; 
  3901. } SHNAMEMAPPING,   *LPSHNAMEMAPPING; 
  3902.  
  3903. typedef struct _SID_AND_ATTRIBUTES { 
  3904.   PSID  Sid; 
  3905.   DWORD Attributes; 
  3906. } SID_AND_ATTRIBUTES ; 
  3907.  
  3908. typedef SID_AND_ATTRIBUTES SID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY];
  3909. typedef SID_AND_ATTRIBUTES_ARRAY *PSID_AND_ATTRIBUTES_ARRAY;
  3910.  
  3911. typedef struct _SINGLE_LIST_ENTRY { 
  3912.   struct _SINGLE_LIST_ENTRY *Next; 
  3913. } SINGLE_LIST_ENTRY; 
  3914.  
  3915. typedef struct tagSOUNDSENTRY {  
  3916.   UINT cbSize; 
  3917.   DWORD dwFlags; 
  3918.   DWORD iFSTextEffect; 
  3919.   DWORD iFSTextEffectMSec; 
  3920.   DWORD iFSTextEffectColorBits; 
  3921.   DWORD iFSGrafEffect; 
  3922.   DWORD iFSGrafEffectMSec; 
  3923.   DWORD iFSGrafEffectColor; 
  3924.   DWORD iWindowsEffect; 
  3925.   DWORD iWindowsEffectMSec; 
  3926.   LPTSTR lpszWindowsEffectDLL; 
  3927.   DWORD iWindowsEffectOrdinal; 
  3928. } SOUNDSENTRY, *LPSOUNDSENTRY; 
  3929.  
  3930. typedef struct tagSTARTUPINFOA { 
  3931.   DWORD   cb; 
  3932.   LPSTR   lpReserved; 
  3933.   LPSTR   lpDesktop; 
  3934.   LPSTR   lpTitle; 
  3935.   DWORD   dwX; 
  3936.   DWORD   dwY; 
  3937.   DWORD   dwXSize; 
  3938.   DWORD   dwYSize; 
  3939.   DWORD   dwXCountChars; 
  3940.   DWORD   dwYCountChars; 
  3941.   DWORD   dwFillAttribute; 
  3942.   DWORD   dwFlags; 
  3943.   WORD    wShowWindow; 
  3944.   WORD    cbReserved2; 
  3945.   LPBYTE  lpReserved2; 
  3946.   HANDLE  hStdInput; 
  3947.   HANDLE  hStdOutput; 
  3948.   HANDLE  hStdError; 
  3949. } STARTUPINFOA, *PSTARTUPINFOA, *LPSTARTUPINFOA; 
  3950.  
  3951. typedef struct tagSTARTUPINFOW { 
  3952.   DWORD   cb; 
  3953.   LPWSTR  lpReserved; 
  3954.   LPWSTR  lpDesktop; 
  3955.   LPWSTR  lpTitle; 
  3956.   DWORD   dwX; 
  3957.   DWORD   dwY; 
  3958.   DWORD   dwXSize; 
  3959.   DWORD   dwYSize; 
  3960.   DWORD   dwXCountChars; 
  3961.   DWORD   dwYCountChars; 
  3962.   DWORD   dwFillAttribute; 
  3963.   DWORD   dwFlags; 
  3964.   WORD    wShowWindow; 
  3965.   WORD    cbReserved2; 
  3966.   LPBYTE  lpReserved2; 
  3967.   HANDLE  hStdInput; 
  3968.   HANDLE  hStdOutput; 
  3969.   HANDLE  hStdError; 
  3970. } STARTUPINFOW, *PSTARTUPINFOW, *LPSTARTUPINFOW; 
  3971.  
  3972. #ifdef    UNICODE
  3973. typedef    STARTUPINFOW    STARTUPINFO;
  3974. typedef    PSTARTUPINFOW    PSTARTUPINFO;
  3975. typedef    LPSTARTUPINFOW    LPSTARTUPINFO;
  3976. #else
  3977. typedef    STARTUPINFOA    STARTUPINFO;
  3978. typedef    PSTARTUPINFOA    PSTARTUPINFO;
  3979. typedef    LPSTARTUPINFOA    LPSTARTUPINFO;
  3980. #endif
  3981.  
  3982. typedef struct tagSTICKYKEYS {  
  3983.   DWORD cbSize; 
  3984.   DWORD dwFlags; 
  3985. } STICKYKEYS, *LPSTICKYKEYS; 
  3986.  
  3987. typedef struct _STRRET { 
  3988.   UINT uType; 
  3989.   union 
  3990.     { 
  3991.       LPWSTR pOleStr;        
  3992.       UINT   uOffset;        
  3993.       char   cStr[MAX_PATH]; 
  3994.     } DUMMYUNIONNAME; 
  3995. } STRRET, *LPSTRRET; 
  3996.  
  3997. typedef struct _tagSTYLEBUF {
  3998.   DWORD  dwStyle;           
  3999.   CHAR  szDescription[32];  
  4000. } STYLEBUF, *LPSTYLEBUF;
  4001.  
  4002. typedef struct tagSTYLESTRUCT {  
  4003.   DWORD styleOld;    
  4004.   DWORD styleNew;    
  4005. } STYLESTRUCT, * LPSTYLESTRUCT; 
  4006.  
  4007. typedef struct _SYSTEM_AUDIT_ACE { 
  4008.   ACE_HEADER  Header; 
  4009.   ACCESS_MASK Mask; 
  4010.   DWORD       SidStart; 
  4011. } SYSTEM_AUDIT_ACE; 
  4012.  
  4013. typedef struct _SYSTEM_INFO
  4014. { 
  4015.   union
  4016.     {
  4017.       DWORD dwOemID;
  4018.       struct
  4019.         {
  4020.           WORD wProcessorArchitecture;
  4021.           WORD wReserved;
  4022.         }
  4023.       s;
  4024.     }
  4025.   u;
  4026.   DWORD  dwPageSize; 
  4027.   LPVOID lpMinimumApplicationAddress; 
  4028.   LPVOID lpMaximumApplicationAddress; 
  4029.   DWORD  dwActiveProcessorMask; 
  4030.   DWORD  dwNumberOfProcessors; 
  4031.   DWORD  dwProcessorType; 
  4032.   DWORD  dwAllocationGranularity; 
  4033.   WORD  wProcessorLevel; 
  4034.   WORD  wProcessorRevision; 
  4035. } SYSTEM_INFO, *LPSYSTEM_INFO; 
  4036.  
  4037. typedef struct _SYSTEM_POWER_STATUS {
  4038.   BYTE ACLineStatus;           
  4039.   BYTE  BatteryFlag;           
  4040.   BYTE  BatteryLifePercent;    
  4041.   BYTE  Reserved1;             
  4042.   DWORD  BatteryLifeTime;      
  4043.   DWORD  BatteryFullLifeTime;  
  4044. } SYSTEM_POWER_STATUS, *LPSYSTEM_POWER_STATUS;
  4045.  
  4046. typedef struct _TAPE_ERASE { 
  4047.   ULONG Type; 
  4048. } TAPE_ERASE; 
  4049.  
  4050. typedef struct _TAPE_GET_DRIVE_PARAMETERS { 
  4051.   BOOLEAN ECC; 
  4052.   BOOLEAN Compression; 
  4053.   BOOLEAN DataPadding; 
  4054.   BOOLEAN ReportSetmarks; 
  4055.   ULONG   DefaultBlockSize; 
  4056.   ULONG   MaximumBlockSize; 
  4057.   ULONG   MinimumBlockSize; 
  4058.   ULONG   MaximumPartitionCount; 
  4059.   ULONG   FeaturesLow; 
  4060.   ULONG   FeaturesHigh; 
  4061.   ULONG   EOTWarningZoneSize; 
  4062. } TAPE_GET_DRIVE_PARAMETERS; 
  4063.  
  4064. typedef struct _TAPE_GET_MEDIA_PARAMETERS {  
  4065.   LARGE_INTEGER   Capacity; 
  4066.   LARGE_INTEGER   Remaining; 
  4067.   DWORD   BlockSize; 
  4068.   DWORD   PartitionCount; 
  4069.   BOOLEAN WriteProtected; 
  4070.   BOOLEAN reserved[7];
  4071. } TAPE_GET_MEDIA_PARAMETERS; 
  4072.  
  4073. typedef struct _TAPE_GET_POSITION { 
  4074.   ULONG Type; 
  4075.   ULONG Partition; 
  4076.   ULONG OffsetLow; 
  4077.   ULONG OffsetHigh; 
  4078. } TAPE_GET_POSITION; 
  4079.  
  4080. typedef struct _TAPE_PREPARE { 
  4081.   ULONG Operation; 
  4082. } TAPE_PREPARE; 
  4083.  
  4084. typedef struct _TAPE_SET_DRIVE_PARAMETERS { 
  4085.   BOOLEAN ECC; 
  4086.   BOOLEAN Compression; 
  4087.   BOOLEAN DataPadding; 
  4088.   BOOLEAN ReportSetmarks; 
  4089.   ULONG   EOTWarningZoneSize; 
  4090. } TAPE_SET_DRIVE_PARAMETERS; 
  4091.  
  4092. typedef struct _TAPE_SET_MEDIA_PARAMETERS { 
  4093.   ULONG BlockSize; 
  4094. } TAPE_SET_MEDIA_PARAMETERS; 
  4095.  
  4096. typedef struct _TAPE_SET_POSITION { 
  4097.   ULONG Method; 
  4098.   ULONG Partition; 
  4099.   ULONG OffsetLow; 
  4100.   ULONG OffsetHigh; 
  4101. } TAPE_SET_POSITION; 
  4102.  
  4103. typedef struct _TAPE_WRITE_MARKS { 
  4104.   ULONG Type; 
  4105.   ULONG Count; 
  4106. } TAPE_WRITE_MARKS; 
  4107.  
  4108. typedef struct {  
  4109.   HINSTANCE hInst; 
  4110.   UINT nID; 
  4111. } TBADDBITMAP, *LPTBADDBITMAP; 
  4112.  
  4113. typedef struct _TBBUTTON { 
  4114.   int iBitmap; 
  4115.   int idCommand; 
  4116.   BYTE fsState; 
  4117.   BYTE fsStyle; 
  4118.   DWORD dwData; 
  4119.   int iString; 
  4120. } TBBUTTON,  * PTBBUTTON,  * LPTBBUTTON; 
  4121. typedef const TBBUTTON  * LPCTBBUTTON; 
  4122.  
  4123. typedef struct { 
  4124.   NMHDR hdr; 
  4125.   int iItem; 
  4126.   TBBUTTON tbButton; 
  4127.   int cchText; 
  4128.   LPTSTR pszText; 
  4129. } TBNOTIFY,  *LPTBNOTIFY; 
  4130.  
  4131. typedef struct { 
  4132.   HKEY hkr; 
  4133.   LPCTSTR pszSubKey; 
  4134.   LPCTSTR pszValueName; 
  4135. } TBSAVEPARAMS; 
  4136.  
  4137. typedef struct _TC_HITTESTINFO { 
  4138.   POINT pt;     
  4139.   UINT  flags;  
  4140. } TC_HITTESTINFO; 
  4141.  
  4142. typedef struct _TC_ITEM { 
  4143.   UINT mask;         
  4144.   UINT lpReserved1;  
  4145.   UINT lpReserved2;  
  4146.   LPTSTR pszText;     
  4147.   int cchTextMax;    
  4148.   int iImage;        
  4149.   LPARAM lParam;     
  4150. } TC_ITEM; 
  4151.  
  4152. typedef struct _TC_ITEMHEADER { 
  4153.   UINT mask;         
  4154.   UINT lpReserved1;  
  4155.   UINT lpReserved2;  
  4156.   LPTSTR pszText;     
  4157.   int cchTextMax;    
  4158.   int iImage;        
  4159. } TC_ITEMHEADER; 
  4160.  
  4161. typedef struct _TC_KEYDOWN { 
  4162.   NMHDR hdr;    
  4163.   WORD wVKey;   
  4164.   UINT flags;
  4165. } TC_KEYDOWN; 
  4166.  
  4167. typedef struct _textrange { 
  4168.   CHARRANGE chrg; 
  4169.   LPSTR lpstrText; 
  4170. } TEXTRANGE; 
  4171.  
  4172. typedef struct _TIME_ZONE_INFORMATION { 
  4173.   LONG       Bias; 
  4174.   WCHAR      StandardName[ 32 ]; 
  4175.   SYSTEMTIME StandardDate; 
  4176.   LONG       StandardBias; 
  4177.   WCHAR      DaylightName[ 32 ]; 
  4178.   SYSTEMTIME DaylightDate; 
  4179.   LONG       DaylightBias; 
  4180. } TIME_ZONE_INFORMATION, *LPTIME_ZONE_INFORMATION; 
  4181.  
  4182. typedef struct tagTOGGLEKEYS {   
  4183.   DWORD cbSize; 
  4184.   DWORD dwFlags; 
  4185. } TOGGLEKEYS; 
  4186.  
  4187. typedef struct _TOKEN_SOURCE {
  4188.   CHAR SourceName[8]; 
  4189.   LUID SourceIdentifier; 
  4190. } TOKEN_SOURCE; 
  4191.  
  4192. typedef struct _TOKEN_CONTROL { 
  4193.   LUID TokenId; 
  4194.   LUID AuthenticationId; 
  4195.   LUID ModifiedId; 
  4196.   TOKEN_SOURCE TokenSource; 
  4197. } TOKEN_CONTROL ; 
  4198.  
  4199. typedef struct _TOKEN_DEFAULT_DACL {  
  4200.   PACL DefaultDacl; 
  4201. } TOKEN_DEFAULT_DACL; 
  4202.  
  4203. typedef struct _TOKEN_GROUPS { 
  4204.   DWORD GroupCount; 
  4205.   SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY]; 
  4206. } TOKEN_GROUPS, *PTOKEN_GROUPS, *LPTOKEN_GROUPS; 
  4207.  
  4208. typedef struct _TOKEN_OWNER { 
  4209.   PSID Owner; 
  4210. } TOKEN_OWNER; 
  4211.  
  4212. typedef struct _TOKEN_PRIMARY_GROUP { 
  4213.   PSID PrimaryGroup; 
  4214. } TOKEN_PRIMARY_GROUP; 
  4215.  
  4216. typedef struct _TOKEN_PRIVILEGES { 
  4217.   DWORD PrivilegeCount; 
  4218.   LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY]; 
  4219. } TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES, *LPTOKEN_PRIVILEGES; 
  4220.  
  4221. typedef struct _TOKEN_STATISTICS { 
  4222.   LUID  TokenId; 
  4223.   LUID  AuthenticationId; 
  4224.   LARGE_INTEGER ExpirationTime; 
  4225.   TOKEN_TYPE    TokenType; 
  4226.   SECURITY_IMPERSONATION_LEVEL ImpersonationLevel; 
  4227.   DWORD DynamicCharged; 
  4228.   DWORD DynamicAvailable; 
  4229.   DWORD GroupCount; 
  4230.   DWORD PrivilegeCount; 
  4231.   LUID  ModifiedId; 
  4232. } TOKEN_STATISTICS; 
  4233.  
  4234. typedef struct _TOKEN_USER { 
  4235.   SID_AND_ATTRIBUTES User; 
  4236. } TOKEN_USER; 
  4237.  
  4238. typedef struct {  
  4239.   UINT      cbSize;    
  4240.   UINT      uFlags;    
  4241.   HWND      hwnd;      
  4242.   UINT      uId;       
  4243.   RECT      rect;      
  4244.   HINSTANCE hinst;     
  4245.   LPTSTR     lpszText;  
  4246. } TOOLINFO,   *PTOOLINFO,   *LPTOOLINFO; 
  4247.  
  4248. typedef struct { 
  4249.   NMHDR     hdr;        
  4250.   LPTSTR    lpszText;   
  4251.   char      szText[80]; 
  4252.   HINSTANCE hinst;      
  4253.   UINT      uFlags;     
  4254. } TOOLTIPTEXT,   *LPTOOLTIPTEXT; 
  4255.  
  4256. typedef struct tagTPMPARAMS { 
  4257.   UINT cbSize; 
  4258.   RECT rcExclude; 
  4259. } TPMPARAMS,   *LPTPMPARAMS; 
  4260.  
  4261. typedef struct _TRANSMIT_FILE_BUFFERS {  
  4262.   PVOID Head; 
  4263.   DWORD HeadLength; 
  4264.   PVOID Tail; 
  4265.   DWORD TailLength; 
  4266. } TRANSMIT_FILE_BUFFERS; 
  4267.  
  4268. typedef struct _TT_HITTESTINFO { 
  4269.   HWND hwnd;   
  4270.   POINT pt;    
  4271.   TOOLINFO ti; 
  4272. } TTHITTESTINFO,   * LPHITTESTINFO; 
  4273.  
  4274. typedef struct tagTTPOLYCURVE { 
  4275.   WORD    wType; 
  4276.   WORD    cpfx; 
  4277.   POINTFX apfx[1]; 
  4278. } TTPOLYCURVE,  * LPTTPOLYCURVE; 
  4279.  
  4280. typedef struct _TTPOLYGONHEADER { 
  4281.   DWORD   cb; 
  4282.   DWORD   dwType; 
  4283.   POINTFX pfxStart; 
  4284. } TTPOLYGONHEADER,  * LPTTPOLYGONHEADER; 
  4285.  
  4286. typedef struct _TV_DISPINFO { 
  4287.   NMHDR   hdr;  
  4288.   TV_ITEM item;  
  4289. } TV_DISPINFO; 
  4290.  
  4291. typedef struct _TVHITTESTINFO { 
  4292.   POINT     pt;     
  4293.   UINT      flags;  
  4294.   HTREEITEM hItem;  
  4295. } TV_HITTESTINFO,   *LPTV_HITTESTINFO; 
  4296.  
  4297. typedef struct _TV_INSERTSTRUCT { 
  4298.   HTREEITEM hParent;       
  4299.   HTREEITEM hInsertAfter;  
  4300.   TV_ITEM   item;          
  4301. } TV_INSERTSTRUCT,   *LPTV_INSERTSTRUCT; 
  4302.  
  4303. typedef struct _TV_KEYDOWN {
  4304.   NMHDR hdr;    
  4305.   WORD  wVKey;  
  4306.   UINT  flags;  
  4307. } TV_KEYDOWN; 
  4308.  
  4309. typedef struct _TV_SORTCB { 
  4310.   HTREEITEM    hParent;       
  4311.   PFNTVCOMPARE lpfnCompare;   
  4312.   LPARAM       lParam;        
  4313. } TV_SORTCB,   *LPTV_SORTCB;  
  4314.  
  4315. typedef struct { 
  4316.   UINT nSec;   
  4317.   UINT nInc;   
  4318. } UDACCEL; 
  4319.  
  4320. typedef struct _ULARGE_INTEGER { 
  4321.   DWORD LowPart; 
  4322.   DWORD HighPart; 
  4323. } ULARGE_INTEGER, *PULARGE_INTEGER; 
  4324.  
  4325. typedef struct _UNIVERSAL_NAME_INFO { 
  4326.   LPTSTR  lpUniversalName; 
  4327. } UNIVERSAL_NAME_INFO; 
  4328.  
  4329. typedef struct tagUSEROBJECTFLAGS { 
  4330.   WINBOOL fInherit; 
  4331.   WINBOOL fReserved; 
  4332.   DWORD dwFlags; 
  4333. } USEROBJECTFLAGS; 
  4334.  
  4335. typedef struct value_ent {
  4336.     LPTSTR   ve_valuename;
  4337.     DWORD ve_valuelen;
  4338.     DWORD ve_valueptr;
  4339.     DWORD ve_type;
  4340. } VALENT, *PVALENT;
  4341.  
  4342. typedef struct _VERIFY_INFORMATION { 
  4343.   LARGE_INTEGER  StartingOffset; 
  4344.   DWORD  Length; 
  4345. } VERIFY_INFORMATION ; 
  4346.  
  4347. typedef struct _VS_FIXEDFILEINFO { 
  4348.   DWORD dwSignature; 
  4349.   DWORD dwStrucVersion; 
  4350.   DWORD dwFileVersionMS; 
  4351.   DWORD dwFileVersionLS; 
  4352.   DWORD dwProductVersionMS; 
  4353.   DWORD dwProductVersionLS; 
  4354.   DWORD dwFileFlagsMask; 
  4355.   DWORD dwFileFlags; 
  4356.   DWORD dwFileOS; 
  4357.   DWORD dwFileType; 
  4358.   DWORD dwFileSubtype; 
  4359.   DWORD dwFileDateMS; 
  4360.   DWORD dwFileDateLS; 
  4361. } VS_FIXEDFILEINFO; 
  4362.  
  4363. typedef struct _WIN32_FIND_DATAA { 
  4364.   DWORD dwFileAttributes; 
  4365.   FILETIME ftCreationTime; 
  4366.   FILETIME ftLastAccessTime; 
  4367.   FILETIME ftLastWriteTime; 
  4368.   DWORD    nFileSizeHigh; 
  4369.   DWORD    nFileSizeLow; 
  4370.   DWORD    dwReserved0; 
  4371.   DWORD    dwReserved1; 
  4372.   CHAR     cFileName[ MAX_PATH ]; 
  4373.   CHAR     cAlternateFileName[ 14 ]; 
  4374. } WIN32_FIND_DATAA, *LPWIN32_FIND_DATAA, *PWIN32_FIND_DATAA; 
  4375.  
  4376. typedef struct _WIN32_FIND_DATAW { 
  4377.   DWORD dwFileAttributes; 
  4378.   FILETIME ftCreationTime; 
  4379.   FILETIME ftLastAccessTime; 
  4380.   FILETIME ftLastWriteTime; 
  4381.   DWORD    nFileSizeHigh; 
  4382.   DWORD    nFileSizeLow; 
  4383.   DWORD    dwReserved0; 
  4384.   DWORD    dwReserved1; 
  4385.   WCHAR    cFileName[ MAX_PATH ]; 
  4386.   WCHAR    cAlternateFileName[ 14 ]; 
  4387. } WIN32_FIND_DATAW, *LPWIN32_FIND_DATAW, *PWIN32_FIND_DATAW; 
  4388.  
  4389. #ifdef    UNICODE
  4390. typedef    WIN32_FIND_DATAW    WIN32_FIND_DATA;
  4391. #else
  4392. typedef    WIN32_FIND_DATAA    WIN32_FIND_DATA;
  4393. #endif
  4394. typedef    WIN32_FIND_DATA    *LPWIN32_FIND_DATA, *PWIN32_FIND_DATA;
  4395.  
  4396.  
  4397. typedef struct _WIN32_STREAM_ID { 
  4398.   DWORD dwStreamId; 
  4399.   DWORD dwStreamAttributes; 
  4400.   LARGE_INTEGER Size; 
  4401.   DWORD dwStreamNameSize; 
  4402.   WCHAR *cStreamName ; 
  4403. } WIN32_STREAM_ID;
  4404.  
  4405. typedef struct _WINDOWPLACEMENT {  
  4406.   UINT  length;               
  4407.   UINT  flags;                
  4408.   UINT  showCmd;              
  4409.   POINT ptMinPosition;        
  4410.   POINT ptMaxPosition;        
  4411.   RECT  rcNormalPosition;     
  4412. } WINDOWPLACEMENT; 
  4413.  
  4414. typedef struct _WNDCLASSA {  
  4415.   UINT    style; 
  4416.   WNDPROC lpfnWndProc; 
  4417.   int     cbClsExtra; 
  4418.   int     cbWndExtra; 
  4419.   HANDLE  hInstance; 
  4420.   HICON   hIcon; 
  4421.   HCURSOR hCursor; 
  4422.   HBRUSH  hbrBackground; 
  4423.   LPCSTR  lpszMenuName; 
  4424.   LPCSTR  lpszClassName; 
  4425. } WNDCLASSA, *LPWNDCLASSA; 
  4426.  
  4427. typedef struct _WNDCLASSW {  
  4428.   UINT    style; 
  4429.   WNDPROC lpfnWndProc; 
  4430.   int     cbClsExtra; 
  4431.   int     cbWndExtra; 
  4432.   HANDLE  hInstance; 
  4433.   HICON   hIcon; 
  4434.   HCURSOR hCursor; 
  4435.   HBRUSH  hbrBackground; 
  4436.   LPCWSTR lpszMenuName; 
  4437.   LPCWSTR lpszClassName; 
  4438. } WNDCLASSW, *LPWNDCLASSW; 
  4439.  
  4440. #ifdef    UNICODE
  4441. typedef    WNDCLASSW    WNDCLASS;
  4442. #else
  4443. typedef    WNDCLASSA    WNDCLASS;
  4444. #endif
  4445. typedef    WNDCLASS    *LPWNDCLASS;
  4446.  
  4447. typedef struct _WNDCLASSEXA { 
  4448.   UINT    cbSize; 
  4449.   UINT    style; 
  4450.   WNDPROC lpfnWndProc; 
  4451.   int     cbClsExtra; 
  4452.   int     cbWndExtra; 
  4453.   HANDLE  hInstance; 
  4454.   HICON   hIcon; 
  4455.   HCURSOR hCursor; 
  4456.   HBRUSH  hbrBackground; 
  4457.   LPCSTR  lpszMenuName; 
  4458.   LPCSTR  lpszClassName; 
  4459.   HICON   hIconSm; 
  4460. } WNDCLASSEXA, *LPWNDCLASSEXA; 
  4461.  
  4462. typedef struct _WNDCLASSEXW { 
  4463.   UINT    cbSize; 
  4464.   UINT    style; 
  4465.   WNDPROC lpfnWndProc; 
  4466.   int     cbClsExtra; 
  4467.   int     cbWndExtra; 
  4468.   HANDLE  hInstance; 
  4469.   HICON   hIcon; 
  4470.   HCURSOR hCursor; 
  4471.   HBRUSH  hbrBackground; 
  4472.   LPCWSTR lpszMenuName; 
  4473.   LPCWSTR lpszClassName; 
  4474.   HICON   hIconSm; 
  4475. } WNDCLASSEXW, *LPWNDCLASSEXW; 
  4476.  
  4477. #ifdef UNICODE
  4478. typedef    WNDCLASSEXW    WNDCLASSEX, *LPWNDCLASSEX;
  4479. #else
  4480. typedef    WNDCLASSEXA    WNDCLASSEX, *LPWNDCLASSEX;
  4481. #endif
  4482.  
  4483. typedef struct _CONNECTDLGSTRUCT {
  4484.   DWORD cbStructure;
  4485.   HWND hwndOwner;
  4486.   LPNETRESOURCE lpConnRes;
  4487.   DWORD dwFlags;
  4488.   DWORD dwDevNum;
  4489. } CONNECTDLGSTRUCT, *LPCONNECTDLGSTRUCT;
  4490.  
  4491. typedef struct _DISCDLGSTRUCT {
  4492.   DWORD           cbStructure;
  4493.   HWND            hwndOwner;
  4494.   LPTSTR           lpLocalName;
  4495.   LPTSTR           lpRemoteName;
  4496.   DWORD           dwFlags;
  4497. } DISCDLGSTRUCT, *LPDISCDLGSTRUCT;
  4498.  
  4499. typedef struct _NETINFOSTRUCT{
  4500.     DWORD cbStructure;
  4501.     DWORD dwProviderVersion;
  4502.     DWORD dwStatus;
  4503.     DWORD dwCharacteristics;
  4504.     DWORD dwHandle;
  4505.     WORD  wNetType;
  4506.     DWORD dwPrinters;
  4507.     DWORD dwDrives;
  4508. } NETINFOSTRUCT, *LPNETINFOSTRUCT;
  4509.  
  4510. typedef struct _NETCONNECTINFOSTRUCT{
  4511.   DWORD cbStructure;
  4512.   DWORD dwFlags;
  4513.   DWORD dwSpeed;
  4514.   DWORD dwDelay;
  4515.   DWORD dwOptDataSize;
  4516. } NETCONNECTINFOSTRUCT, *LPNETCONNECTINFOSTRUCT;
  4517.  
  4518. typedef int CALLBACK (*ENUMMETAFILEPROC) (HDC, HANDLETABLE, 
  4519.                       METARECORD, int, LPARAM);
  4520. typedef int CALLBACK (*ENHMETAFILEPROC) (HDC, HANDLETABLE, 
  4521.                      ENHMETARECORD, int, LPARAM);
  4522.  
  4523. typedef int CALLBACK (*ENUMFONTSPROC) (LPLOGFONT, LPTEXTMETRIC, DWORD, LPARAM);
  4524. typedef int CALLBACK (*FONTENUMPROC) (ENUMLOGFONT *, NEWTEXTMETRIC *, 
  4525.                       int, LPARAM);
  4526. typedef int CALLBACK (*FONTENUMEXPROC) (ENUMLOGFONTEX *, NEWTEXTMETRICEX *, 
  4527.                       int, LPARAM);
  4528.  
  4529. typedef VOID CALLBACK (*LPOVERLAPPED_COMPLETION_ROUTINE) (DWORD, DWORD, 
  4530.                               LPOVERLAPPED);
  4531.  
  4532. /*
  4533.   Structures for the extensions to OpenGL
  4534.   */
  4535. typedef struct _POINTFLOAT 
  4536. {
  4537.   FLOAT   x;
  4538.   FLOAT   y;
  4539. } POINTFLOAT, *PPOINTFLOAT;
  4540.  
  4541. typedef struct _GLYPHMETRICSFLOAT
  4542. {
  4543.   FLOAT       gmfBlackBoxX;
  4544.   FLOAT       gmfBlackBoxY;
  4545.   POINTFLOAT  gmfptGlyphOrigin;
  4546.   FLOAT       gmfCellIncX;
  4547.   FLOAT       gmfCellIncY;
  4548. } GLYPHMETRICSFLOAT, *PGLYPHMETRICSFLOAT, *LPGLYPHMETRICSFLOAT;
  4549.  
  4550. typedef struct tagLAYERPLANEDESCRIPTOR
  4551. {
  4552.   WORD  nSize; 
  4553.   WORD  nVersion; 
  4554.   DWORD dwFlags; 
  4555.   BYTE  iPixelType; 
  4556.   BYTE  cColorBits; 
  4557.   BYTE  cRedBits; 
  4558.   BYTE  cRedShift; 
  4559.   BYTE  cGreenBits; 
  4560.   BYTE  cGreenShift; 
  4561.   BYTE  cBlueBits; 
  4562.   BYTE  cBlueShift; 
  4563.   BYTE  cAlphaBits; 
  4564.   BYTE  cAlphaShift; 
  4565.   BYTE  cAccumBits; 
  4566.   BYTE  cAccumRedBits; 
  4567.   BYTE  cAccumGreenBits; 
  4568.   BYTE  cAccumBlueBits; 
  4569.   BYTE  cAccumAlphaBits; 
  4570.   BYTE  cDepthBits; 
  4571.   BYTE  cStencilBits; 
  4572.   BYTE  cAuxBuffers; 
  4573.   BYTE  iLayerPlane;
  4574.   BYTE  bReserved; 
  4575.   COLORREF crTransparent; 
  4576. } LAYERPLANEDESCRIPTOR, *PLAYERPLANEDESCRIPTOR, *LPLAYERPLANEDESCRIPTOR; 
  4577.  
  4578. typedef struct tagPIXELFORMATDESCRIPTOR
  4579. {
  4580.   WORD  nSize;
  4581.   WORD  nVersion;
  4582.   DWORD dwFlags;
  4583.   BYTE  iPixelType;
  4584.   BYTE  cColorBits;
  4585.   BYTE  cRedBits;
  4586.   BYTE  cRedShift;
  4587.   BYTE  cGreenBits;
  4588.   BYTE  cGreenShift;
  4589.   BYTE  cBlueBits;
  4590.   BYTE  cBlueShift;
  4591.   BYTE  cAlphaBits;
  4592.   BYTE  cAlphaShift;
  4593.   BYTE  cAccumBits;
  4594.   BYTE  cAccumRedBits;
  4595.   BYTE  cAccumGreenBits;
  4596.   BYTE  cAccumBlueBits;
  4597.   BYTE  cAccumAlphaBits;
  4598.   BYTE  cDepthBits;
  4599.   BYTE  cStencilBits;
  4600.   BYTE  cAuxBuffers;
  4601.   BYTE  iLayerType;
  4602.   BYTE  bReserved;
  4603.   DWORD dwLayerMask;
  4604.   DWORD dwVisibleMask;
  4605.   DWORD dwDamageMask;
  4606. } PIXELFORMATDESCRIPTOR, *PPIXELFORMATDESCRIPTOR, *LPPIXELFORMATDESCRIPTOR;
  4607.  
  4608. typedef struct
  4609. {
  4610.   LPWSTR    usri2_name;
  4611.   LPWSTR    usri2_password;
  4612.   DWORD     usri2_password_age;
  4613.   DWORD     usri2_priv;
  4614.   LPWSTR    usri2_home_dir;
  4615.   LPWSTR    usri2_comment;
  4616.   DWORD     usri2_flags;
  4617.   LPWSTR    usri2_script_path;
  4618.   DWORD     usri2_auth_flags;
  4619.   LPWSTR    usri2_full_name;
  4620.   LPWSTR    usri2_usr_comment;
  4621.   LPWSTR    usri2_parms;
  4622.   LPWSTR    usri2_workstations;
  4623.   DWORD     usri2_last_logon;
  4624.   DWORD     usri2_last_logoff;
  4625.   DWORD     usri2_acct_expires;
  4626.   DWORD     usri2_max_storage;
  4627.   DWORD     usri2_units_per_week;
  4628.   PBYTE     usri2_logon_hours;
  4629.   DWORD     usri2_bad_pw_count;
  4630.   DWORD     usri2_num_logons;
  4631.   LPWSTR    usri2_logon_server;
  4632.   DWORD     usri2_country_code;
  4633.   DWORD     usri2_code_page;
  4634. } USER_INFO_2, *PUSER_INFO_2, *LPUSER_INFO_2;
  4635.  
  4636. typedef struct
  4637. {
  4638.   LPWSTR    usri0_name;
  4639. } USER_INFO_0, *PUSER_INFO_0, *LPUSER_INFO_0;
  4640.  
  4641. typedef struct
  4642. {
  4643.   LPWSTR    usri3_name;
  4644.   LPWSTR    usri3_password;
  4645.   DWORD     usri3_password_age;
  4646.   DWORD     usri3_priv;
  4647.   LPWSTR    usri3_home_dir;
  4648.   LPWSTR    usri3_comment;
  4649.   DWORD     usri3_flags;
  4650.   LPWSTR    usri3_script_path;
  4651.   DWORD     usri3_auth_flags;
  4652.   LPWSTR    usri3_full_name;
  4653.   LPWSTR    usri3_usr_comment;
  4654.   LPWSTR    usri3_parms;
  4655.   LPWSTR    usri3_workstations;
  4656.   DWORD     usri3_last_logon;
  4657.   DWORD     usri3_last_logoff;
  4658.   DWORD     usri3_acct_expires;
  4659.   DWORD     usri3_max_storage;
  4660.   DWORD     usri3_units_per_week;
  4661.   PBYTE     usri3_logon_hours;
  4662.   DWORD     usri3_bad_pw_count;
  4663.   DWORD     usri3_num_logons;
  4664.   LPWSTR    usri3_logon_server;
  4665.   DWORD     usri3_country_code;
  4666.   DWORD     usri3_code_page;
  4667.   DWORD     usri3_user_id;
  4668.   DWORD     usri3_primary_group_id;
  4669.   LPWSTR    usri3_profile;
  4670.   LPWSTR    usri3_home_dir_drive;
  4671.   DWORD     usri3_password_expired;
  4672. } USER_INFO_3, *PUSER_INFO_3, *LPUSER_INFO_3;
  4673.  
  4674. typedef struct
  4675. {
  4676.   LPWSTR   grpi2_name;
  4677.   LPWSTR   grpi2_comment;
  4678.   DWORD    grpi2_group_id;
  4679.   DWORD    grpi2_attributes;
  4680. } GROUP_INFO_2, *PGROUP_INFO_2;
  4681.  
  4682. typedef struct
  4683. {
  4684.   LPWSTR   lgrpi0_name;
  4685. } LOCALGROUP_INFO_0, *PLOCALGROUP_INFO_0, *LPLOCALGROUP_INFO_0;
  4686.  
  4687. /* PE executable header.  */
  4688.  
  4689. typedef struct tagIMAGE_DOS_HEADER
  4690. {
  4691.     WORD    e_magic;
  4692.     WORD    e_cblp;        /* Bytes on last page of file */
  4693.     WORD    e_cp;        /* Pages in file */
  4694.     WORD    e_crlc;        /* Relocations */
  4695.     WORD    e_cparhdr;    /* Size of header in paragraphs */
  4696.     WORD    e_minalloc;    /* Minimum extra paragraphs needed */
  4697.     WORD    e_maxalloc;    /* Maximum extra paragraphs needed */
  4698.     WORD    e_ss;        /* Initial (relative) SS */
  4699.     WORD    e_sp;        /* Initial SP */
  4700.     WORD    e_csum;        /* Checksum */
  4701.     WORD    e_ip;        /* Initial IP */
  4702.     WORD    e_cs;        /* Initial (relative) CS */
  4703.     WORD    e_lfarlc;    /* File address of relocation table */
  4704.     WORD    e_ovno;        /* Overlay number */
  4705.     WORD    e_res[4];    /* Reserved */
  4706.     WORD    e_oemid;    /* OEM identifier */
  4707.     WORD    e_oeminfo;    /* OEM specific information */
  4708.     WORD    e_res2[10];    /* Reserved */
  4709.     LONG    e_lfanew;    /* File address of new exe header */
  4710. } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
  4711.  
  4712. typedef struct tagIMAGE_OS2_HEADER
  4713. {
  4714.     WORD    ne_magic;
  4715.     CHAR    ne_ver;        /* Version number */
  4716.     CHAR    ne_rev;        /* Revision number */
  4717.     WORD    ne_enttab;    /* Offset of entry table */
  4718.     WORD    ne_cbenttab;    /* Size of entry table in bytes */
  4719.     LONG    ne_crc;        /* Checksum of entire file */
  4720.     WORD    ne_flags;
  4721.     WORD    ne_autodata;    /* Automatic data segment number */
  4722.     WORD    ne_heap;    /* Initial heap */
  4723.     WORD    ne_stack;    /* Initial stack */
  4724.     LONG    ne_csip;    /* Initial CS:IP */
  4725.     LONG    ne_sssp;    /* Initial SS:SP */
  4726.     WORD    ne_cseg;    /* Count of file segments */
  4727.     WORD    ne_cmod;    /* Entries in module reference table */
  4728.     WORD    ne_cbnrestab;    /* Size of non-resident name table in bytes */
  4729.     WORD    ne_segtab;    /* Offset of segment table */
  4730.     WORD    ne_rsrctab;    /* Offset of resource table */
  4731.     WORD    ne_restab;    /* Offset of resident name table */
  4732.     WORD    ne_modtab;    /* Offset of module reference table */
  4733.     WORD    ne_imptab;    /* Offset of imported name table */
  4734.     LONG    ne_nrestab;    /* Offset of non-resident name table */
  4735.     WORD    ne_cmovent;    /* Count of movable entries */
  4736.     WORD    ne_align;    /* Segment alignment shift count */
  4737.     WORD    ne_cres;    /* Count of resource segments */
  4738.     BYTE    ne_exetyp;    /* Target OS */
  4739.     BYTE    ne_flagsothers;    /* Other flags */
  4740.     WORD    ne_pretthunks;    /* Offset to return thunks */
  4741.     WORD    ne_psegrefbytes;    /* Offset to segment ref. bytes */
  4742.     WORD    ne_swaparea;    /* Minimum code swap area size */
  4743.     WORD    ne_expver;    /* Expected Windows version number */
  4744. } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER;
  4745.  
  4746. typedef struct tagIMAGE_VXD_HEADER
  4747. {
  4748.     WORD    e32_magic;
  4749.     BYTE    e32_border;    /* Byte ordering */
  4750.     BYTE    e32_worder;    /* Word ordering */
  4751.     DWORD    e32_level;    /* Format level (= 0) */
  4752.     WORD    e32_cpu;    /* CPU type */
  4753.     WORD    e32_os;        /* OS type */
  4754.     DWORD    e32_ver;    /* Module version */
  4755.     DWORD    e32_mflags;    /* Module flags */
  4756.     DWORD    e32_mpages;    /* Number of module pages */
  4757.     DWORD    e32_startobj;    /* Object number for instruction pointer */
  4758.     DWORD    e32_eip;    /* Extended instruction pointer */
  4759.     DWORD    e32_stackobj;    /* Object number for stack pointer */
  4760.     DWORD    e32_esp;    /* Extended stack pointer */
  4761.     DWORD    e32_pagesize;    /* Page size */
  4762.     DWORD    e32_lastpagesize;    /* Size of last page */
  4763.     DWORD    e32_fixupsize;    /* Fixup section size */
  4764.     DWORD    e32_fisupsum;    /* Fixup section checksum */
  4765.     DWORD    e32_ldrsize;    /* Loader section size */
  4766.     DWORD    e32_ldrsum;    /* Loader section checksum */
  4767.     DWORD    e32_objtab;    /* Object table offset */
  4768.     DWORD    e32_objcnt;    /* Count of objects */
  4769.     DWORD    e32_objmap;    /* Object page map offset */
  4770.     DWORD    e32_itermap;    /* Object iterated data map offset */
  4771.     DWORD    e32_rsrctab;    /* Offset of resource table */
  4772.     DWORD    e32_rsrccnt;    /* Number of resources */
  4773.     DWORD    e32_restab;    /* Offset of resident name table */
  4774.     DWORD    e32_enttab;    /* Offset of entry table */
  4775.     DWORD    e32_dirtab;    /* Offset of module directive table */
  4776.     DWORD    e32_dircnt;    /* Number of module directives */
  4777.     DWORD    e32_fpagetab;    /* Offset of fixup page table */
  4778.     DWORD    e32_frectab;    /* Offset of fixup record table */
  4779.     DWORD    e32_impmod;    /* Offset of import module name table */
  4780.     DWORD    e32_impmodcnt;    /* Number of import module names */
  4781.     DWORD    e32_impproc;    /* Offset of import procedure name table */
  4782.     DWORD    e32_pagesum;    /* Offset of per-page checksum table */
  4783.     DWORD    e32_datapage;    /* Offset of enumerated data pages */
  4784.     DWORD    e32_preload;    /* Offset of preload pages */
  4785.     DWORD    e32_nrestab;    /* Offset of non-resident name table */
  4786.     DWORD    e32_cbnrestab;    /* Size of non-resident name table in bytes */
  4787.     DWORD    e32_nressum;    /* Non-resident name table checksum */
  4788.     DWORD    e32_autodata;    /* Object number for automatic data object */
  4789.     DWORD    e32_debuginfo;    /* Offset of debugging information */
  4790.     DWORD    e32_debuglen;    /* Size of debugging information in bytes */
  4791.     DWORD    e32_instpreload;    /* Number of instance pages in preload section */
  4792.     DWORD    e32_instdemand;    /* Number of instance pages in demand load section */
  4793.     DWORD    e32_heapsize;    /* Size of heap - for 16-bit apps */
  4794.     BYTE    e32_res3[12];    /* Reserved */
  4795.     DWORD    e32_winresoff;    /* Offset of windows resources ? */
  4796.     DWORD    e32_winreslen;    /* Size of windows resources in bytes ? */
  4797.     WORD    e32_devid;    /* Device ID */
  4798.     WORD    e32_ddkver;    /* DDK version */
  4799. } IMAGE_VXD_HEADER, *PIMAGE_VXD_HEADER;
  4800.  
  4801. #ifdef __cplusplus
  4802. }
  4803. #endif /* __cplusplus */
  4804.  
  4805. #endif    /* RC_INVOKED */
  4806.  
  4807. #endif /* _GNU_H_WINDOWS32_STRUCTURES */
  4808.  
  4809.